VBnet

UNIVERSIDAD NACIONAL DEL CENTRO DEL PERU

INSTITUTO DE INVESTIGACIÓN

FACULTAD DE INGENIERÍA DE SISTEMAS

INFORME FINAL

LIBRO: “PROGRAMACIÓN CON VISUAL BASIC .NET”

PROGRAMA : Transformación de Recursos SUB PROGRAMA : Tecnologías LÍNEA : Informática Aplicada

FECHA DE INICIO : 15 MARZO DEL 2005 FECHA DE CULMINACIÓN : 15 DICIEMBRE DEL 2005 TRIMESTRE : III

EJECUTORES :

APELLIDOS Y NOMBRES CONDICION CATEGORIA DEDICACION FIRMA Abraham Esteban Gamarra Moreno Nombrado Asociado T.C. Job Daniel Gamarra Moreno Colaborador Juan Gamarra Moreno Colaborador José Yarasca Bejarano Contratado Auxiliar T.P.

___________________________ ____________________________ Ing° Fidel O. Arauco Canturin M.Sc. Hugo Miguel Miguel DIRECTOR DEL INSTITUTO DE DIRECTOR DEL CENTRO DE INVESTIGACION DE LA FIS INVESTIGACION DE LA UNCP

Huancayo, 15 de diciembre de 2005.

UNIVERSIDAD NACIONAL DEL CENTRO DEL PERÚ

Programación con Visual Basic .NET

Abraham Esteban Gamarra Moreno

Job Daniel Gamarra Moreno

Juan Gamarra Moreno

José Yarasca Bejarano

2005

ii PROGRAMACION CON VISUAL BASIC.NET

CONTENIDO

INTRODUCCION ...........................................................................................................................................1

CAPITULO UNO.............................................................................................................................................3

FUNDAMENTOS DEL VISUAL BASIC .NET............................................................................................3 1.1. INTRODUCCIÓN A VISUAL STUDIO.NET ...............................................................................3 1.2. OBJETIVO DEL .NET ...................................................................................................................3 1.3. EL ENTORNO DE TRABAJO .NET FRAMEWORK...................................................................3 1.4. UN PRIMER EJEMPLO.................................................................................................................6

CAPITULO DOS ...........................................................................................................................................11

TIPOS DE DATOS VARIABLES Y OPERADORES................................................................................11 2.1. RESUMEN DE TIPOS DE DATOS .............................................................................................11

2.1.1. CONSUMO DE MEMORIA .....................................................................................................12 2.2. CLASIFICACIÓN DE TIPOS ......................................................................................................13

2.2.1. Tipos de valor...........................................................................................................................13 2.2.2. Tipos de referencia...................................................................................................................13

2.3. VARIABLES ................................................................................................................................14 2.3.1. DECLARACIÓN DE VARIABLES ...........................................................................................14 2.3.2. NIVELES DE DECLARACIÓN................................................................................................14 2.3.3. Declarar el tipo de datos..........................................................................................................15 2.3.4. Declarar el período de duración..............................................................................................16 2.3.5. Declarar el ámbito ...................................................................................................................16 2.3.6. Declarar la accesibilidad.........................................................................................................17 2.3.7. EJEMPLOS DE DECLARACIONES DE VARIABLES ............................................................17

2.4. OPERADORES ARITMÉTICOS.................................................................................................18 2.4.1. Operaciones aritméticas ..........................................................................................................19

2.5. OPERADORES DE COMPARACIÓN ........................................................................................20 2.5.1. COMPARAR VALORES NUMÉRICOS ...................................................................................20 2.5.2. Comparar cadenas ...................................................................................................................21 2.5.3. Comparar objetos.....................................................................................................................22

2.6. OPERADORES DE CONCATENACIÓN ...................................................................................24 2.7. OPERADORES LÓGICOS ..........................................................................................................25

CAPITULO TRES .........................................................................................................................................29

ESTRUCTURAS DE CONTROL (LÓGICA CONDICIONAL) ..............................................................29 3.1. IF...THEN...ELSE (INSTRUCCIONES)................................................................................................29 3.2. SELECT...CASE...............................................................................................................................35 3.3. INSTRUCCIONES WHILE...END WHILE ...........................................................................................38 3.4. DO...LOOP .....................................................................................................................................39 3.5. FOR...NEXT....................................................................................................................................40 3.6. EJEMPLOS DEL USO DE ESTRUCTURAS DE CONTROL.....................................................42

CAPITULO CUATRO ..................................................................................................................................47

MATRICES....................................................................................................................................................47 4.1. INFORMACIÓN GENERAL SOBRE LAS MATRICES .............................................................................47

4.1.1. Dimensiones de matriz .............................................................................................................47 4.1.2. Tamaño de matriz.....................................................................................................................48

4.2. DECLARAR VARIABLES DE MATRIZ ................................................................................................48 4.2.1. Inicializar matrices ..................................................................................................................49

A.Gamarra M.- D.Gamarra M. - J.Gamarra M. – J. Yarasca B. iii

4.2.2. Límites de tamaño de matriz.................................................................................................... 51 4.2.3. Cambiar el tamaño de matrices............................................................................................... 51

4.3. USAR LAS MATRICES ..................................................................................................................... 52 4.3.1. Matrices multidimensionales ................................................................................................... 53

4.4. CARACTERÍSTICAS AVANZADAS DE LAS MATRICES ....................................................................... 54 4.4.1. Asignación de matrices............................................................................................................ 54 4.4.2. Devolver una matriz desde una función .................................................................................. 55

4.5. EJEMPLO DEL USO DE ARREGLOS Y LISTBOX .................................................................. 56 CAPITULO CINCO...................................................................................................................................... 59

PROCEDIMIENTOS.................................................................................................................................... 59 5.1. PROCEDIMIENTOS SUB........................................................................................................... 59

5.1.1. Declaración de argumentos..................................................................................................... 60 5.1.2. Sintaxis de llamada.................................................................................................................. 60

5.2. RETURN (INSTRUCCIÓN) ............................................................................................................... 61 5.3. PROCEDIMIENTOS FUNCTION ........................................................................................................ 62

5.3.1. Valores devueltos..................................................................................................................... 62 5.3.2. Sintaxis de llamada.................................................................................................................. 64

5.4. FUNCIONES MATEMÁTICAS ........................................................................................................... 65 5.5. EJEMPLO DEL USO DE SUB Y FUNCTION ......................................................................................... 70

CAPITULO SEIS .......................................................................................................................................... 75

GRÁFICOS GDI+ ......................................................................................................................................... 75 6.1. CREAR IMÁGENES GRÁFICAS CON GDI+ ....................................................................................... 76

6.1.1. Crear un objeto Graphics........................................................................................................ 76 6.1.2. PaintEventArgs en el controlador de eventos Paint ................................................................ 77 6.1.3. CreateGraphics (Método)........................................................................................................ 77 6.1.4. Crear un objeto Graphics a partir de un objeto Image ........................................................... 78

6.2. DIBUJAR Y MANIPULAR FORMAS E IMÁGENES ............................................................................... 78 6.2.1. Dibujar líneas y formas con GDI+.......................................................................................... 79

6.3. EJEMPLO 1 DEL USO DE GRAFICOS GDI+......................................................................................... 80 6.4. GRAPHICS (MÉTODOS DE) ............................................................................................................. 82

BIBLIOGRAFIA........................................................................................................................................... 91

INDICE ALFABETICO ............................................................................................................................... 93

iv PROGRAMACION CON VISUAL BASIC.NET

A.Gamarra M.- D.Gamarra M. - J.Gamarra M. – J. Yarasca B. 1

INTRODUCCION

Desde que Microsoft ha lanzado Visual Studio .NET, una plata-forma con cuatro lenguajes de programación, surge la necesi-dad de conocer como elaborar aplicaciones para Windows y/o aplicaciones para la Web.

Uno de los lenguajes más utilizados desde visual Studio 6.0, ha sido el Visual Basic y el lenguaje que evoluciona a este es el Visual Basic .NET por lo que para el presente libro se sientan las bases para el dominio de este último.

El primer capítulo trata de los fundamentos del Visual Basic .NET, en el segundo capítulo se describe los tipos de datos, variables y operadores del Visual Basic .NET; el tercer capí-tulo describe las estructuras de control, el cuarto capítulo muestra el uso de las matrices, el quinto capítulo trata so-bre el uso de los procedimientos y el sexto capítulo trata sobre los gráficos GDI+.


CAPITULO UNO

FUNDAMENTOS DEL VISUAL BASIC .NET

1.1. INTRODUCCIÓN A VISUAL STUDIO.NET Visual Studio .NET es un conjunto completo de herra-mientas de desarrollo para la construcción de aplica-ciones Web ASP, servicios Web XML, aplicaciones para escritorio y aplicaciones móviles. Visual Basic .NET, Visual C++ .NET, Visual C# .NET y Visual J# .NET uti-lizan el mismo entorno de desarrollo integrado (IDE), que les permite compartir herramientas y facilita la creación de soluciones en varios lenguajes. Asimismo, dichos lenguajes aprovechan las funciones de .NET Fra-mework, que ofrece acceso a tecnologías clave para simplificar el desarrollo de aplicaciones Web ASP y servicios Web XML.

1.2. OBJETIVO DEL .NET El objetivo final de la iniciativa .NET es transportar la información al usuario de una forma más limpia, más rápida y más accesible. La figura 1.1 muestra esta perspectiva.

1.3. EL ENTORNO DE TRABAJO .NET FRAMEWORK El entorno .NET Framework es el corazón de la plata-forma .NET. Este entorno de trabajo proporciona los

4 PROGRAMACION CON VISUAL BASIC.NET

servicios necesarios para desarrollar e implantar las aplicaciones dentro del deslavazado entorno de Inter-net. La Figura 1.2 ilustra los componentes clave de esta estructura.

Figura 1.1 Objetivo final de la iniciativa .NET

.NET Framework es una nueva plataforma informática que simplifica el desarrollo de aplicaciones en un entorno altamente distribuido como es Internet. El diseño de .NET Framework está enfocado a cumplir los objetivos siguientes:

• Proporcionar un entorno coherente de programación orientada a objetos, en el que el código de los objetos se pueda almacenar y ejecutar de forma local, ejecutar de forma local pero distribuida en Internet o ejecutar de forma remota.


• Proporcionar un entorno de ejecución de código que reduzca lo máximo posible la implementación de software y los conflictos de versiones.

Figura 1.2 Estructura del entorno de trabajo Framework .NET

• Ofrecer un entorno de ejecución de código que ga-rantice la ejecución segura del mismo, incluso del creado por terceras personas desconocidas o que no son de plena confianza.

• Proporcionar un entorno de ejecución de código que elimine los problemas de rendimiento de los entornos en los que se utilizan secuencias de co-mandos o intérpretes de comandos.

• Ofrecer al programador una experiencia coherente entre tipos de aplicaciones muy diferentes, como las basadas en Windows o en el Web.


• Basar toda la comunicación en estándares del sec-tor para asegurar que el código de .NET Framework se puede integrar con otros tipos de código.

.NET Framework contiene dos componentes principales: Common Language Runtime (Fundamentos comunes entre lenguajes) y la biblioteca de clases de .NET Frame-work.

Common Language Runtime es el fundamento de la tecno-logía. El motor de tiempo de ejecución se puede consi-derar como un agente que administra el código en tiem-po de ejecución y proporciona servicios centrales, co-mo la administración de memoria, la administración de subprocesos y la interacción remota, al tiempo que aplica una seguridad estricta a los tipos y otras for-mas de especificación del código que garantizan su se-guridad y solidez. De hecho, el concepto de adminis-tración de código es un principio básico del motor de tiempo de ejecución. El código destinado al motor de tiempo de ejecución se denomina código administrado, a diferencia del resto de código, que se conoce como có-digo no administrado.

La biblioteca de clases, el otro componente principal de .NET Framework, es una completa colección orientada a objetos de tipos reutilizables que se pueden emplear para desarrollar aplicaciones que abarcan desde las tradicionales herramientas de interfaz gráfica de usuario (GUI) o de línea de comandos hasta las aplica-ciones basadas en las innovaciones más recientes pro-porcionadas por ASP.NET, como los formularios Web Forms y los servicios Web XML.

1.4. UN PRIMER EJEMPLO En este ítem mostramos la creación de nuestra primera aplicación. Ingrese al Visual Studio .NET 2003 (figura 1.3).


Figura 1.3 Ingreso al Visual Studio .NET 2003

Elija Archivo, Nuevo, Proyecto; para iniciar la crea-ción de un nuevo proyecto (figura 1.4).

Figura 1.4


Elija Aplicación para windows, escriba un nombre para el proyecto y elija un directorio de trabajo (figura 1.5).

Figura 1.5

Ahora tenemos un formulario tal como se muestra en la figura 1.6.

En el cuadro de herramientas, ficha windows forms, elija Label, desplácese al formulario y abra una caja de texto. Para cambiar el contenido del texto, en la ventana propiedades elija text y escriba “Mi primer ejemplo”, luego cambie el tamaño del fuente en Font. La figura 1.7. muestra el efecto final.

Para ejecutar el programa presione la tecla F5 o elija el icono Iniciar. El resultado de la ejecución del programa se muestra en la figura 1.8.


Figura 1.6

Figura 1.7


Figura 1.8


CAPITULO DOS

TIPOS DE DATOS VARIABLES Y OPERA-DORES

2.1. RESUMEN DE TIPOS DE DATOS La tabla siguiente muestra los tipos de datos de Vi-sual Basic .NET, los tipos correspondientes de Common Language Runtime, su asignación de almacenamiento no-minal y sus intervalos de valores.

Tipo de Visual Basic

Estructura de tipo Common Language

Runtime

Asignación de almacena-miento nomi-

nal

Intervalo de valores

Boolean

System.Boolean 2 bytes True o False

Byte System.Byte 1 byte 0 a 255 (sin signo) Char System.Char 2 bytes 0 a 65535 (sin signo) Date System.DateTime 8 bytes 0:00:00 del 1 de enero de 0001 a

11:59:59 p.m. del 31 de diciembre de 9999.

Decimal System.Decimal 16 bytes 0 a +/-79.228.162.514.264.337.593.543.950.335 sin separador decimal; 0 a +/-7,9228162514264337593543950335 con 28 posiciones a la derecha del signo decimal; el número más pequeño distinto de cero es +/-0,0000000000000000000000000001 (+/-1E-28).


Double (punto flotante con preci-sión do-ble)

System.Double 8 bytes -1,79769313486231570E+308 a -4,94065645841246544E-324 para valores negativos; 4,94065645841246544E-324 a 1,79769313486231570E+308 para valores positivos.

Integer System.Int32 4 bytes -2.147.483.648 a 2.147.483.647 Long (entero largo)

System.Int64 8 bytes -9.223.372.036.854.775.808 a 9.223.372.036.854.775.807.

Object System.Object (clase)

4 bytes Cualquier tipo puede almacenarse en una variable de tipo Object.

Short System.Int16 2 bytes -32.768 a 32.767. Single (punto flotante con preci-sión sim-ple)

System.Single 4 bytes -3,4028235E+38 a –1,401298E-45 para valores negativos; 1,401298E-45 a 3,4028235E+38 para valores positivos.

String (cadena de longitud variable)

System.String (clase)

En función de la plata-forma de implementa-ción

De 0 a 2.000 millones de caracteres Unicode aprox.

Tipo de datos de-finido por el usuario (estructu-ra)

(hereda de Sys-tem.ValueType)

En función de la plata-forma de implementa-ción

Cada miembro de la estructura tiene un intervalo de valores determinado por su tipo de datos e independiente de los intervalos de valores correspon-dientes a los demás miembros.

Nota En el caso de cadenas que contienen texto, uti-lice la función StrConv para convertir de un formato de texto a otro.

2.1.1. CONSUMO DE MEMORIA

Al declarar un tipo de datos básico, no debe suponerse que su consumo de memoria es igual a su asignación de almacenamiento nominal. Common Language Runtime asigna el almacena-miento en función de las características de la plataforma en la que se ejecuta la aplica-ción. En algunas situaciones, empaqueta los elementos declarados en el menor espacio po-sible; en otros casos alinea las direcciones de memoria con los límites naturales del hardware. Además, la asignación de almacena-miento es diferente en las plataformas de 64 bits y 32 bits.

Las mismas consideraciones se aplican a cada miembro de un tipo de datos compuesto como una estructura o una matriz. Además, algunos


tipos compuestos tienen requisitos adiciona-les de memoria. Por ejemplo, una matriz uti-liza memoria adicional para la matriz en sí y para cada dimensión. En una plataforma de 32 bits, esta sobrecarga corresponde a 12 bytes y 8 bytes por cada dimensión. En una plata-forma de 64 bits, los requisitos se duplican. No se puede sumar simplemente todas las asig-naciones de almacenamiento nominales de los componentes.

Una variable Object que haga referencia a un tipo de datos básico o compuesto, utiliza 4 bytes además de los datos contenidos en el tipo de datos.

2.2. CLASIFICACIÓN DE TIPOS El sistema de tipos común es compatible con dos cate-gorías generales de tipos, que a su vez se dividen en subcategorías:

2.2.1. TIPOS DE VALOR

Los tipos de valor contienen directamente sus datos y las instancias de los tipos de valor se asignan en la pila o se asignan en línea en una estructura. Los tipos de valor pueden ser integrados (implementados por el motor de tiempo de ejecución), definidos por el usua-rio o enumeraciones. Las variables que son tipos de valor tienen, cada una, su propia copia de los datos y, por lo tanto, las ope-raciones en una variable no afectan a las de-más.

2.2.2. TIPOS DE REFERENCIA

Los tipos de referencia guardan una referen-cia a la dirección en memoria del valor y se asignan en el montón. Los tipos de referencia pueden ser tipos autodescriptivos, de puntero o de interfaz. El tipo de un tipo de referen-cia se puede determinar a partir de los valo-res de los tipos autodescriptivos. Los tipos autodescriptivos se dividen en matrices y ti-pos de clase. Los tipos de clase son clases definidas por el usuario, tipos de valor a


los que se ha aplicado la conversión boxing y delegados. Las variables que son tipos de re-ferencia pueden hacer referencia al mismo ob-jeto y, por lo tanto, las operaciones en una variable pueden afectar al mismo objeto al que hace referencia otra variable.

2.3. VARIABLES

Identificadores son conjuntos de letras y/o números que se utilizan para simbolizar todos los elementos que en un programa son definibles por el usuario (pro-gramador o ingeniero de software) del mismo como son las variables donde se almacenan datos, funciones( pe-queños módulos con código), etiquetas, clases, obje-tos, etc.

Una variable se define como un identificador que se utiliza para almacenar todos los datos generados du-rante la ejecución de un programa.

Existen ciertas reglas en cuanto a variables:

• Claras y con referencia directa al problema.

• No espacios en blanco, ni símbolos extraños en ellas.

• Se pueden usar abreviaturas, pero solo de carác-ter general.

• No deben ser palabras reservadas del lenguaje.

Algunos ejemplos de variables son: Nombre, Edad, Sdo-Diario, IngMensual, Perímetro, Calif1, etc.

2.3.1. DECLARACIÓN DE VARIABLES

Una variable se declara para especificar su nombre y sus características. La instrucción de declaración para variables es Dim. Su ubi-cación y contenido determinan las caracterís-ticas de la variable.

2.3.2. NIVELES DE DECLARACIÓN

Una variable local es aquella que se declara dentro de un procedimiento. Una variable de


módulo se declara en el interior del módulo, pero no dentro de un procedimiento interno del módulo.

La categoría de una variable que no sea lo-cal, en una clase o estructura, depende de que la variable esté o no compartida. Si una variable se declara con la palabra clave Sha-red, es una variable compartida, y existe en una única copia compartida por todas las ins-tancias de la clase o estructura. De lo con-trario, es una variable de instancia, y se crea una copia independiente de ella para ca-da instancia de la clase o estructura. Una copia determinada de una variable de instan-cia sólo está disponible en la instancia para la cual se creó.

2.3.3. DECLARAR EL TIPO DE DATOS

La cláusula As de la instrucción de declara-ción permite definir el tipo de datos o de objetos de la variable que se está declaran-do. Se puede especificar cualquiera de los siguientes tipos para una variable:

• Un tipo de datos elemental, como Boolean, Long o Decimal.

• Un tipo de datos compuesto, como una ma-triz o una estructura.

• Un tipo de objeto, o de clase, de Visual Basic u otra aplicación, como Label o TextBox.

Se pueden declarar distintas variables en la misma instrucción sin necesidad de repetir el tipo de datos. En las instrucciones que se muestran a continuación, las variables I, J y K se declaran como de tipo Integer, L y M co-mo Long y X e Y como Single:

Dim I, J, K As Integer ' All three are Integer variables. Dim L, M As Long, X, Y As Single ' L and M are Long, X and Y are Single.


2.3.4. DECLARAR EL PERÍODO DE DURACIÓN

El período de duración de una variable repre-senta el tiempo durante el cual la variable está disponible para que pueda ser utilizada. Una variable local declarada con una instruc-ción Dim sólo existe durante la ejecución del procedimiento. Cuando finaliza el procedi-miento, todas sus variables locales desapare-cen y sus valores se pierden. No obstante, si se declara una variable local con la palabra clave Static, ésta seguirá existiendo y con-servará su valor aunque finalice el procedi-miento.

Las variables de módulo, compartidas y de instancia conservan sus valores mientras continúe la ejecución de la aplicación.

2.3.5. DECLARAR EL ÁMBITO

El ámbito de una variable está formado por todo código que puede hacer referencia a la variable sin tener que especificar su nombre. El ámbito de una variable está determinado por la ubicación en la que se haya declarado la variable. El código de una región determi-nada puede utilizar las variables definidas en dicha región sin necesidad de especificar los nombres de las variables. Cuando se de-clara un ámbito, se aplican las siguientes reglas:

• El ámbito de una variable de módulo es el espacio de nombres completo en el que está definido el módulo.

• El ámbito de una variable de instancia o compartida es la estructura o clase en la que se ha declarado.

• El ámbito de una variable local es el procedimiento en el que se ha declarado.

• No obstante, si se declara una variable local dentro de un bloque, su ámbito se-rá únicamente el propio bloque. Un blo-que es un conjunto de instrucciones que


terminan por una instrucción End, Else, Loop o Next; por ejemplo, una construc-ción For...Next o If...Then...Else...End If.

2.3.6. DECLARAR LA ACCESIBILIDAD

La accesibilidad de una variable viene deter-minada por la palabra o palabras clave, Dim, Public, Protected, Friend, Protected Friend o Private, que se utilizan en la instrucción de declaración. Con cualquiera de estas palabras clave se puede declarar una variable de módu-lo, estructura, clase o instancia. Dentro de un procedimiento, solamente está permitida la palabra clave Dim, y la accesibilidad siempre es privada.

2.3.7. EJEMPLOS DE DECLARACIONES DE VARIABLES

Para asignar a una variable un valor se pro-cede de la siguiente manera

• se declara la variable y

• luego se asigna con el operador “=”. Se presentan 2 opciones:

a. Dim va As Integer

va=5

b. Dim va As Integer=5

Y las constantes se declaran como

Const n as Integer=10

En esta línea no usamos Dim porque es cons-tante precisamente.

También se pueden declarar varias variables en una misma línea por ejemplo:

Dim a,b,c As Short

En la línea anterior a, b y c serán de tipo Short


Lo anterior se pudo haber escrito como:

Dim a As Short

Dim b As Short

Dim c As Short

O bien

Dim a As Short,b As Short,c As Short

No es recomendable dejar una variable sin in-dicar el tipo por ejemplo:

Dim i

Esto generaría un error después de declarar la Option Strict en On, porque indicaría que no se debe dejar sin declarar el tipo.

Algo que no se puede hacer es lo siguiente:

Dim i,b As short=5

Porque generaría un error indicando que no se puede inicializar varias variables al tiempo.

Lo cual se haría de la siguiente manera:

Dim a As Short,b As short=5

Aunque solo b tendrá un valor de 5

Igualmente

Dim a As Short,b,c As integer,d As Short=3

Sólo d tendrá un valor de 3

Todas las variables numéricas al no iniciali-zarlas tendrán como valor inicial 0, las va-riables de tipo char tendrán un null o vacía.

2.4. OPERADORES ARITMÉTICOS Los operadores aritméticos se utilizan para realizar muchas de las operaciones aritméticas habituales que implican el cálculo de valores numéricos representados


por literales, variables, otras expresiones, llamadas a funciones y propiedades, y constantes.

2.4.1. OPERACIONES ARITMÉTICAS

Puede sumar dos valores en una expresión con el operador + o restar un valor de otro con el operador -, como se muestra en los si-guientes ejemplos:

Dim x As Integer

x = 67 + 34

x = 32 - 12

La negación también utiliza el operador -, pero con una sintaxis algo diferente, como se muestra a continuación:

Dim x As Integer = 65

Dim y As Integer

y = -x

La multiplicación y la división utilizan los operadores * y /, respectivamente, como en estos ejemplos:

Dim y As Double

y = 45 * 55.23

y = 32 / 23

La exponenciación utiliza el operador ^, como se muestra a continuación:

Dim z As Double

z = 23 ^ 3 ' z equals the cube of 23.

La división de enteros se lleva a cabo con el operador \. La división de enteros devuelve el número de veces que un entero puede divi-dirse exactamente en otro. Con este operador, sólo se pueden utilizar tipos enteros (Byte,


Short, Integer y Long). Todos los demás tipos deben convertirse antes a tipo integral. A continuación se muestra un ejemplo de una división de enteros:

Dim k As Integer

k = 23 \ 5 ' k = 4

El módulo aritmético se calcula con el opera-dor Mod. Este operador devuelve el resto una vez que se divide el divisor por el dividendo un número integral de veces. Si tanto el di-visor como el dividendo son tipos integrales, el valor devuelto es integral. Si el divisor y el dividendo son tipos de punto flotante, el valor devuelto es una variable de punto flotante. Dos ejemplos ilustran este compor-tamiento:

Dim x As integer = 100

Dim y As Integer = 6

Dim z As Integer

z = x Mod y ' z equals 4.

Dim a As Double = 100.3

Dim b As Double = 4.13

Dim c As Double

c = a Mod b ' c equals 1.18.

2.5. OPERADORES DE COMPARACIÓN Los operadores de comparación comparan dos expresiones y devuelven un valor Boolean que representa el resul-tado de la comparación. Existen operadores para compa-rar valores numéricos, operadores para comparar cade-nas y operadores para comparar objetos. Los tres tipos de operadores se describen a continuación.

2.5.1. COMPARAR VALORES NUMÉRICOS

Para comparar valores numéricos se utilizan seis operadores de comparación numérica. En la siguiente tabla se muestran los operadores


y un ejemplo de la condición que prueba cada uno.

Operador Condición que prueba Ejemplos = (Igualdad)

¿Es el valor que re-presenta la primera expresión igual que el valor que repre-senta la segunda?

23 = 33 ' False 23 = 23 ' True 23 = 12 ' False

<> (Desigualdad) ¿Es el valor que re-presenta la primera expresión no igual que el valor que re-presenta la segunda?

23 <> 33 ' True 23 <> 23 ' False 23 <> 12 ' True

< (Menor que) ¿Es el valor que re-presenta la primera expresión menor que el valor que repre-senta la segunda?

23 < 33 ' True 23 < 23 ' False 23 < 12 ' False

> (Mayor que) ¿Es el valor que re-presenta la primera expresión mayor que el valor que repre-senta la segunda?

23 > 33 ' False 23 > 23 ' False 23 > 12 ' True

<= (Menor o igual que)

¿Es el valor que re-presenta la primera expresión menor o igual que el valor que representa la segunda?

23 <= 33 ' True 23 <= 23 ' True 23 <= 12 ' False

>= (Mayor o igual que)

¿Es el valor que re-presenta la primera expresión mayor o igual que el valor que representa la segunda?

23 >= 33 ' False 23 >= 23 ' True 23 >= 12 ' True

2.5.2. COMPARAR CADENAS

Para comparar cadenas se utiliza el operador Like, así como los operadores de comparación numérica. El operador Like permite especifi-car un modelo; después se compara la cadena con el modelo y, si coincide, el resultado es True. De lo contrario, el resultado es False. Los operadores numéricos permiten comparar


valores String basándose en el tipo de orde-nación:

"73" < "9" ' This result is True.

El resultado es True porque el primer carác-ter de la primera cadena se ordena antes que el primer carácter de la segunda cadena. Si los primeros caracteres fueran iguales, la comparación continuaría con el siguiente ca-rácter de las dos cadenas, y así sucesivamen-te. La igualdad de cadenas también se puede probar mediante el operador de igualdad, como en este ejemplo:

"734" = "734" ' The result is True.

En este ejemplo, las dos cadenas se comparan directamente y, puesto que son iguales, se devuelve True.

Si una cadena es un prefijo de otra, como "aa" y "aaa", la cadena más larga se ordena después de la más corta. Por tanto, la si-guiente expresión es verdadera (True):

"aaa" > "aa"

El criterio de ordenación se basará en una comparación binaria o una comparación textual en función del valor de Option Compare.

2.5.3. COMPARAR OBJETOS

Puede utilizar el operador Is para determinar si dos variables de objeto hacen referencia a la misma instancia de un objeto. Por ejemplo:

Dim x As MyClass

Dim y As New MyClass()

x = y

If x Is y Then

' Insert code to continue program execu-tion.


En este ejemplo, la evaluación de x Is y de-vuelve True, porque las dos variables hacen referencia a la misma instancia. Compare este resultado con el del ejemplo siguiente:

Dim x As New MyClass()

Dim y As New MyClass()

If x Is y then


En este ejemplo, la evaluación de x Is y de-vuelve False, puesto que aunque las variables son del mismo tipo, hacen referencia a ins-tancias diferentes de ese tipo.

Para probar si un objeto es de un tipo con-creto se utiliza el operador TypeOf...Is. . La sintaxis es la siguiente:

TypeOf <object expression> Is <TypeName>

Cuando TypeName especifica un tipo de inter-faz, el operador TypeOf ... Is devuelve True si el objeto implementa el tipo de interfaz. Cuando TypeName es un tipo de clase, el ope-rador devuelve True (verdadero) si el objeto es una instancia de la clase especificada o una instancia que se deriva de la especifica-da. Por ejemplo:

Dim x As Button

x = New Button()

If TypeOf x Is Control Then


Puesto que el tipo de x es Button, y Button hereda de Control, la expresión TypeOf x Is Con-trol se evalúa como True.


2.6. OPERADORES DE CONCATENACIÓN Los operadores de concatenación combinan varias cade-nas en una sola. Hay dos operadores de concatenación, + y &; ambos llevan a cabo la operación de concatena-ción básica, como se muestra a continuación:

Dim x As String

x = "Con" & "caten" & "ation"

' x equals "Concatenation".

x = "Con" + "caten" + "ation"

' x equals "Concatenation".

Estos operadores también concatenan variables String, como en el ejemplo siguiente:

Dim x As String = "abc"

Dim y As String = "def"

Dim z As String

z = x & y ' z equals "abcdef".

z = x + y ' z equals "abcdef".

Si el valor de Option Strict es On, el operador + re-quiere explícitamente cadenas para las operaciones de concatenación. También realiza operaciones aritméticas con operandos numéricos cuando el valor de Option Strict es On. No obstante, si el valor de Option Strict es Off, el operador + admite una amplia varie-dad de conversiones implícitas para operaciones de concatenación, tal como se muestra en los siguientes ejemplos:

Option Strict On

' Initialize mixed variables.

var1 = "34"

var2 = 6

myNumber = var1 + var2 ' Generates a compile-time error.


Option Strict Off

Var1 = "34"

Var2 = 6

myNumber = var1 + var2

' Returns 40 (addition) after the string in var1 is

' converted to a numeric value. Use of Option Strict Off

' for these operations is not recommended.

El operador & sólo se define para operandos de tipo String y siempre amplía sus operandos a String, inde-pendientemente de la configuración de Option Strict. El operador & está recomendado para la concatenación de cadenas, porque está definido exclusivamente para cadenas y reduce las posibilidades de generar una con-versión no deseada.

2.7. OPERADORES LÓGICOS Los operadores lógicos comparan expresiones Boolean y devuelven un resultado Boolean. Los operadores And, Or, AndAlso, OrElse y Xor aceptan dos operandos, mien-tras que el operador Not sólo acepta un operando.

El operador Not realiza la negación lógica de una ex-presión Boolean. En términos simples, proporciona lo contrario de la expresión que evalúa. Si la evaluación de la expresión devuelve True, Not proporciona False; si devuelve False, Not proporciona True. A continua-ción se muestra un ejemplo:

Dim x As Boolean

x = Not 23 > 12 ' x equals False.

x = Not 23 > 67 ' x equals True.

El operador And realiza la conjunción lógica de dos expresiones Boolean. Es decir, si la evaluación de am-bas expresiones es True, el operador And devuelve True. Si al evaluar una o las dos expresiones se ob-tiene False, And devuelve False.


El operador Or realiza la disyunción lógica de dos ex-presiones Boolean. Si la evaluación de alguna expre-sión devuelve True, Or devuelve True. Si la evaluación de alguna expresión devuelve True, Or devuelve False.

Xor realiza la exclusión lógica en dos expresiones. Si la evaluación de una de las expresiones devuelve True (pero no las dos), Xor devuelve True. Si la evaluación devuelve True o False para las dos expresiones, Xor devuelve False.

A continuación se muestran ejemplos de uso de los ope-radores And, Or y Xor:

Dim x As Boolean

x = 23 > 12 And 12 >4 ' x = True

x = 12 > 23 And 12 > 4 ' x = False

x = 23 > 12 Or 4 > 12` ' x = True

x = 23 > 45 Or 4 > 12 ' x = False

x = 23 > 45 Xor 12 > 4 ' x = True

x = 23 > 12 Xor 12 > 4 ' x = False

x = 12 > 23 Xor 4 > 12 ' x = False

Nota: Además de ser operadores lógicos, Not, Or, And y Xor también realizan operaciones aritméticas bit a bit cuando se utilizan en valores numéricos.

El operador AndAlso es muy similar al operador And, ya que también realiza la conjunción lógica de dos expre-siones Boolean. La diferencia clave entre AndAlso y And es que AndAlso muestra comportamiento de corto-circuito. Si el valor de la primera expresión evaluada de una expresión AndAlso es False, no se evaluará la segunda expresión y se devolverá False para la expre-sión AndAlso.

De manera similar, el operador OrElse realiza la dis-yunción lógica de evaluación "cortocircuitada" de dos expresiones Boolean. Si la evaluación de la primera expresión de una expresión OrElse devuelve True, no se evaluará la segunda expresión y se devolverá True para la expresión OrElse. A continuación se muestran algu-


nos ejemplos que ilustran la diferencia entre And, Or y sus equivalentes:

12 > 45 And MyFunction(4) ' MyFunction() is called.

12 > 45 AndAlso MyFunction(4) ' MyFunction() is not called.

45 > 12 Or MyFunction(4) ' MyFunction is called.

45 > 12 OrElse MyFunction(4) ' MyFunction is not called

En el primer ejemplo, se llama a MyFunction() aunque 12 > 45 devuelve False, debido a que no se "cortocircui-ta" la evaluación de And. En el segundo ejemplo, no se llama a MyFunction porque 12 > 45 devuelve False, con lo cual AndAlso "cortocircuita" la evaluación de la se-gunda expresión. En el tercer ejemplo, se llama a My-Function aunque 45 > 12 devuelve True, debido a que no se "cortocircuita" la evaluación de Or. En el cuarto ejemplo, no se llama a MyFunction porque 45 > 12 devuelve True, con lo cual OrElse "cortocircuita" la evaluación de la segunda expresión.

Nota: Aunque And y Or admiten operaciones bit a bit con valores numéricos, AndAlso y OrElse no lo hacen.


CAPITULO TRES

ESTRUCTURAS DE CONTROL (LÓGICA CONDICIONAL)

Estas estructuras permiten al programa tomar decisiones, en función de los resultados de una condición.

3.1. IF...THEN...ELSE (INSTRUCCIONES) Ejecuta de forma condicional un grupo de instruccio-nes, dependiendo del valor de una expresión.

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

O bien

If condition Then [ statements ] [ Else elsestatements ]

Donde:

Condition: Requerido. La expresión que proporcione en condition debe evaluarse como True o False, o como un


tipo de datos que sea implícitamente convertible a Boolean.

Statements: Opcional en formato de múltiples líneas; se requiere en formato de una sola línea que no tenga una cláusula Else. Se ejecutan una o más instrucciones que siguen a If...Then si condition es True.

Elseifcondition: Requerido si está presente ElseIf. Igual que condition.

Elseifstatements: Opcional. Se ejecutan una o más ins-trucciones que siguen a ElseIf...Then si la elseifcon-dition asociada es True.

Elsestatements: Opcional en formato de múltiples lí-neas; se requiere en formato de una sola línea que tenga una cláusula Else. Una o más instrucciones que se ejecuten si ninguna de las expresiones anteriores condition o elseifcondition es True.

End If: Termina un bloque If...Then.

Nota:

Puede utilizar la forma de una sola línea para pruebas cortas y sencillas. Sin embargo, el formato de múlti-ples líneas proporciona más estructura y flexibilidad que el formato de una sola línea y, generalmente, es más fácil de leer, mantener y depurar.

Con el formato de una sola línea, es posible ejecutar varias instrucciones como resultado de una decisión If...Then. Todas las instrucciones deben estar en la misma línea y separadas por dos puntos, como en el ejemplo siguiente:

If A > 10 Then A = A + 1 : B = B + A : C = C + B

En el formato de múltiples líneas, la instrucción If debe ser la única instrucción en la primera línea. Las instrucciones Else, ElseIf y End If pueden ir precedi-das solamente por una etiqueta de línea. La instruc-ción If...Then...Else de varias líneas debe finalizar con una instrucción End If.

Para determinar si una instrucción If introduce un formato de múltiples líneas, examine lo que sigue a la palabra clave Then. Si aparece cualquier otra cosa que no sea un comentario después de Then en la misma ins-


trucción, ésta se trata como una instrucción If de una sola línea. Si Then no está definida, debe ser el co-mienzo de una instrucción If...Then...Else de múlti-ples líneas.

Las cláusulas ElseIf y Else son opcionales. Puede te-ner tantas cláusulas ElseIf como desee en una instruc-ción If...Then...Else de múltiples líneas, pero no puede aparecer ninguna después de una cláusula Else. Los formatos de múltiples líneas pueden anidarse unos dentro de otros.

Cuando se encuentra una If...Then...Else de múltiples líneas, se prueba condition. Si condition es True, se ejecutan las instrucciones que están a continuación de Then. Si condition es False, se evalúa cada instruc-ción ElseIf en orden. Cuando se encuentra una elseif-condition True, se ejecutan las instrucciones que si-guen inmediatamente a la instrucción Then asociada. Si ninguna elseifcondition se evalúa como True, o no existen instrucciones ElseIf, se ejecutan las instruc-ciones que siguen a Else. Después de la ejecución de las instrucciones que siguen a Then, ElseIf o Else, la ejecución continúa con la instrucción que sigue a End If.

Sugerencia Select...Case puede ser más útil cuando se evalúa una única expresión que tiene varios valores posibles.

Ejemplo (1): Realice un programa que lea un número y calcule el valor absoluto. La entrada de datos y la salida debe utilizar el siguiente formulario:


Solución: Pegue dos controles Label, dos controles TextBox y tres controles Button.

Modifique la propiedad Text de cada control para modi-ficar sus textos.

Realice doble clic en el control para añadir código al programa. El código encerrado es el que debemos añadir para este ejemplo. El código que no está encerrado ha sido generado por el Visual Basic .NET.

Public Class Form1 Inherits System.Windows.Forms.Form #Region " Código generado por el Diseñador de Windows Forms " Public Sub New() MyBase.New() 'El Diseñador de Windows Forms requiere esta llamada. InitializeComponent() 'Agregar cualquier inicialización después de la llamada a Initia-lizeComponent() End Sub 'Form reemplaza a Dispose para limpiar la lista de componentes. Protected Overloads Overrides Sub Dispose(ByVal disposing As Boolean) If disposing Then If Not (components Is Nothing) Then components.Dispose() End If End If MyBase.Dispose(disposing) End Sub 'Requerido por el Diseñador de Windows Forms Private components As System.ComponentModel.IContainer 'NOTA: el Diseñador de Windows Forms requiere el siguiente procedi-miento 'Puede modificarse utilizando el Diseñador de Windows Forms. 'No lo modifique con el editor de código. Friend WithEvents Label1 As System.Windows.Forms.Label Friend WithEvents TextBox1 As System.Windows.Forms.TextBox Friend WithEvents Button1 As System.Windows.Forms.Button Friend WithEvents Label2 As System.Windows.Forms.Label Friend WithEvents TextBox2 As System.Windows.Forms.TextBox Friend WithEvents Button2 As System.Windows.Forms.Button Friend WithEvents Button3 As System.Windows.Forms.Button <System.Diagnostics.DebuggerStepThrough()> Private Sub InitializeCom-ponent() Me.Label1 = New System.Windows.Forms.Label


Me.TextBox1 = New System.Windows.Forms.TextBox Me.Button1 = New System.Windows.Forms.Button Me.Label2 = New System.Windows.Forms.Label Me.TextBox2 = New System.Windows.Forms.TextBox Me.Button2 = New System.Windows.Forms.Button Me.Button3 = New System.Windows.Forms.Button Me.SuspendLayout() ' 'Label1 ' Me.Label1.Location = New System.Drawing.Point(16, 16) Me.Label1.Name = "Label1" Me.Label1.Size = New System.Drawing.Size(104, 24) Me.Label1.TabIndex = 0 Me.Label1.Text = "Ingrese un número" ' 'TextBox1 ' Me.TextBox1.Location = New System.Drawing.Point(136, 16) Me.TextBox1.Name = "TextBox1" Me.TextBox1.Size = New System.Drawing.Size(96, 20) Me.TextBox1.TabIndex = 1 Me.TextBox1.Text = "" ' 'Button1 ' Me.Button1.Location = New System.Drawing.Point(32, 72) Me.Button1.Name = "Button1" Me.Button1.Size = New System.Drawing.Size(136, 24) Me.Button1.TabIndex = 2 Me.Button1.Text = "Halllar el valor absoluto" ' 'Label2 ' Me.Label2.Location = New System.Drawing.Point(16, 128) Me.Label2.Name = "Label2" Me.Label2.Size = New System.Drawing.Size(96, 24) Me.Label2.TabIndex = 3 Me.Label2.Text = "Valor absoluto" ' 'TextBox2 ' Me.TextBox2.Location = New System.Drawing.Point(136, 120) Me.TextBox2.Name = "TextBox2" Me.TextBox2.Size = New System.Drawing.Size(96, 20) Me.TextBox2.TabIndex = 4 Me.TextBox2.Text = "" ' 'Button2 ' Me.Button2.Location = New System.Drawing.Point(24, 176) Me.Button2.Name = "Button2" Me.Button2.Size = New System.Drawing.Size(96, 24) Me.Button2.TabIndex = 5 Me.Button2.Text = "&Limpiar" ' 'Button3 '


Me.Button3.Location = New System.Drawing.Point(152, 176) Me.Button3.Name = "Button3" Me.Button3.Size = New System.Drawing.Size(104, 24) Me.Button3.TabIndex = 6 Me.Button3.Text = "&Salir" ' 'Form1 ' Me.AutoScaleBaseSize = New System.Drawing.Size(5, 13) Me.ClientSize = New System.Drawing.Size(292, 273) Me.Controls.Add(Me.Button3) Me.Controls.Add(Me.Button2) Me.Controls.Add(Me.TextBox2) Me.Controls.Add(Me.Label2) Me.Controls.Add(Me.Button1) Me.Controls.Add(Me.TextBox1) Me.Controls.Add(Me.Label1) Me.Name = "Form1" Me.Text = "Form1" Me.ResumeLayout(False) End Sub #End Region Private Sub TextBox2_TextChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles TextBox2.TextChanged End Sub Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click If TextBox1.Text < 0 Then TextBox2.Text = -1 * TextBox1.Text Else TextBox2.Text = TextBox1.Text End If End Sub Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click TextBox1.Text = "" TextBox2.Text = "" End Sub Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button3.Click End End Sub Private Sub TextBox1_TextChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles TextBox1.TextChanged


End Sub Private Sub TextBox1_Enter(ByVal sender As Object, ByVal e As Sys-tem.EventArgs) Handles TextBox1.Enter End Sub End Class

La ejecución del programa se muestra a continuación:

3.2. SELECT...CASE

Ejecuta uno de varios grupos de instrucciones, según el valor de una expresión.

Select [ Case ] testexpression [ Case expressionlist [ statements ] ] [ Case Else [ elsestatements ] ] End Select

Donde:

Testexpression: Requerido. Expresión. Debe evaluarse en uno de los tipos de datos elementales (Boolean, Byte, Char, Date, Double, Decimal, Integer, Long, Object, Short, Single o String).


Expressionlist: Requerido en una instrucción Case. Lista de cláusulas de expresiones que representan valores que coinciden para testexpression. Las cláusulas de varias expresiones se separan mediante comas. Cada cláusula puede tomar una de las siguientes formas:

• expression1 To expression2

• [ Is ] comparisonoperator expression

• expression

Utilice la palabra clave To para especificar los límites de un intervalo de valores que coinciden para testexpression. El valor de expression1 debe ser menor o igual que el valor de expression2.

Utilice la palabra clave Is con un operador de comparación (=, <>, <, <=, > o >=) para especificar una restricción en los valores coincidentes para testexpression. Si no se escribe, la palabra clave Is se insertará automáticamente antes de comparisonoperator.

La forma que sólo especifica expression se trata como un caso especial de la forma Is donde comparisonoperator es el signo igual (=). Esta forma se evalúa como testexpression = expression.

Las expresiones en expressionlist pueden ser de cualquier tipo de datos, siempre que sean implícitamente convertibles al tipo de testexpression y el correspondiente comparisonoperator sea válido para los dos tipos con los que se utilice.

Statements: Opcional. Una o más instrucciones después de Case que se ejecutan si testexpression coincide con cualquier cláusula en expressionlist.

Elsestatements: Opcional. Una o más instrucciones a continuación de Case Else que se ejecutan si testexpression coincide con cualquier cláusula de expressionlist.

End Select: Termina un bloque Select...Case.


Observaciones:

Si testexpression coincide con cualquier cláusula Case expressionlist, se ejecutan las instrucciones que si-guen a la instrucción Case hasta la siguiente instruc-ción Case o End Select. El control pasa después a la instrucción que sigue a End Select. Si testexpression coincide con una cláusula de testexpression en más de una cláusula Case, sólo se ejecutan las instrucciones que siguen a la primera coincidencia.

La instrucción Case Else se utiliza para introducir las elsestatements que se ejecutarán si no se encuen-tra ninguna coincidencia entre testexpression y una cláusula de expressionlist en cualquiera de las demás instrucciones Case. Aunque no es necesario, es reco-mendable tener una instrucción Case Else en el bloque Select Case para controlar los valores de testexpres-sion imprevistos. Si ninguna cláusula Case expression-list coincide con testexpression y no existe ninguna instrucción Case Else, la ejecución continúa en la instrucción que sigue a End Select.

Se pueden utilizar varias expresiones o intervalos en cada cláusula Case. Por ejemplo, la línea siguiente es válida:

Case 1 To 4, 7 To 9, 11, 13, Is > MaxNumber

Nota La palabra clave Is que se utiliza en las ins-trucciones Case y Case Else no es igual que el opera-dor de comparación Is.

También puede especificar intervalos y varias expre-siones para cadenas de caracteres. En el siguiente ejemplo, Case coincide con cadenas que sean exactamen-te iguales a "apples", cadenas con valores entre "nuts" y "soup" en orden alfabético y con el valor ac-tual de TestItem:

Case "apples", "nuts" To "soup", TestItem

La configuración Option Compare puede afectar a las comparaciones de cadenas. En Option Compare Text, las cadenas "Apples" y "apples" se consideran iguales en la comparación, pero no así en Option Compare Binary.


Las instrucciones Select Case pueden anidarse. Cada instrucción Select Case anidada debe tener una ins-trucción End Select coincidente.

Si no necesita ejecutar más instrucciones de un bloque Case o Case Else, puede salir del bloque mediante una instrucción Exit Select. Esto transfiere inmediatamen-te el control a la instrucción que sigue a End Select.

3.3. INSTRUCCIONES WHILE...END WHILE Ejecuta una serie de instrucciones siempre que una condición dada sea True.

While condition [ statements ] End While

Donde:

Condition: Requerido. Expresión. Debe evaluarse como True o False. Si condition es Nothing, condition se trata como False.

Statements: Opcional. Se ejecutan una o más instruc-ciones que siguen a While si condition es True.

End While: Termina la ejecución del bloque While.

Observaciones:

Si condition es True, se ejecutan todas las instruc-ciones hasta que se encuentre la instrucción End Whi-le. Después, el control vuelve a la instrucción While y se comprueba de nuevo condition. Si condition aún es True, se repite el proceso. Si es False, la ejecución se reanuda con la instrucción que sigue a la instruc-ción End While.

Se pueden anidar bucles While si se coloca un bucle dentro de otro.


3.4. DO...LOOP Repite un bloque de instrucciones mientras una condi-ción Boolean sea True o hasta que la condición se con-vierta en True.

Do { While | Until } condition [ statements ] [ Exit Do ] [ statements ] Loop

O bien

Do [ statements ] [ Exit Do ] [ statements ] Loop { While | Until } condition

Donde:

While: Requerido, a menos que se utilice Until. Pala-bra clave. Repite el bucle hasta que condition sea False.

Until: Requerido, a menos que se utilice While. Pala-bra clave. Repite el bucle hasta que condition sea True.

Condition: Opcional. Boolean. Expresión que se evalúa como True o False.

Statements: Opcional. Una o más instrucciones que se repiten mientras o hasta que condition sea True.

Observaciones:

La instrucción Exit Do transfiere el control inmedia-tamente a la instrucción que sigue a la instrucción Loop. Se puede incluir cualquier número de instruccio-nes Exit Do en cualquier lugar del bucle Do. Exit Do suele utilizarse después de evaluar alguna condición, por ejemplo con If...Then...Else.


3.5. FOR...NEXT Repite un grupo de instrucciones un número de veces especificado.

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

Donde:

Counter: Requerido. Variable. El tipo de datos de counter suele ser Integer, pero puede ser cualquier tipo numérico elemental que admita los operadores ma-yor o igual que (>=), menor o igual que (<=) y suma (+).

Datatype: Requerido, a menos que counter ya se haya declarado. Tipo de datos de counter. Si counter se de-clara fuera de este bucle, no se podrá utilizar la cláusula As para volver a declararlo.

Start: Requerido. Expresión. Valor inicial de counter. La expresión start suele evaluarse como tipo Integer, pero puede evaluarse como cualquier tipo de datos que se amplíe al tipo de counter.

End: Requerido. Expresión. Valor final de counter. La expresión end suele evaluarse como tipo Integer, pero puede evaluarse como cualquier tipo de datos que se amplíe al tipo de counter.

Step: Opcional. Expresión. Cantidad en la que se in-crementa counter cada vez que se ejecuta el bucle. La expresión step suele evaluarse como tipo Integer, pero puede evaluarse como cualquier tipo de datos que se amplíe al tipo de counter. Si no se especifica, el va-lor predeterminado de step es 1.

Statements: Opcional. Una o más instrucciones entre For y Next que se ejecutan un número especificado de veces.

Observaciones:

Si counter no se ha declarado fuera de este bucle, se puede declarar dentro de la instrucción For. En tal


caso, el ámbito de counter es el cuerpo del bucle. Sin embargo, counter no se puede declarar fuera y dentro del bucle.

El argumento step puede ser positivo o negativo. El valor del argumento step determina la manera en que se procesa el bucle, como se muestra a continuación:

Valor de step El bucle se ejecuta siPositivo o cero counter <= end Negativo counter >= end

Las expresiones start, end y step sólo se evalúan una vez, cuando se encuentra por primera vez la instruc-ción For. No se volverán a evaluar, aunque cambien las partes que componen las instrucciones del bucle.

La variable counter se compara con end antes de cada vez que se entra en el bucle. Esto incluye la primera vez que se ejecuta la instrucción For. Por consiguien-te, si el valor de start supera el valor de end al en-trar en el bucle, éste no se ejecuta, y la ejecución pasa inmediatamente a la instrucción que sigue a Next.

Una vez que se han ejecutado las instrucciones del bu-cle, el valor de step se agrega a counter. En este mo-mento, la instrucción For compara de nuevo counter con end. Como resultado de esta comparación, bien se eje-cutan otra vez las instrucciones del bucle o se termi-na el bucle y la ejecución continúa con la instrucción que sigue a Next.

Nota: Cambiar el valor de counter mientras se está dentro de un bucle puede dificultar la lectura y la depuración del código.

La instrucción Exit For transfiere el control inmedia-tamente a la instrucción que sigue a la instrucción Next. Se puede incluir cualquier número de instruccio-nes Exit For en cualquier lugar del bucle For...Next. Exit For suele utilizarse después de evaluar alguna condición, por ejemplo con una instrucción If...Then...Else.


Se pueden anidar bucles For...Next, colocando un bucle dentro de otro. Cada bucle debe tener una variable counter única. La siguiente construcción es correcta:

For I As Integer = 1 To 10 For J As Integer = 1 To 10 For K As Integer = 1 To 10 ' Statements to operate with current values of I, J, and K. Next K Next J Next I

Nota: Si se encuentra una instrucción Next antes que su instrucción For correspondiente, o si una instruc-ción Next de un nivel de anidamiento externo se en-cuentra antes que la instrucción Next de un nivel in-terno, se produce un error.

3.6. EJEMPLOS DEL USO DE ESTRUCTURAS DE CONTROL

Ejemplo ( 2): Escribir un programa que permita leer un número e imprima si es capicúa o no. Usar while.

Solución:

Se utiliza el siguiente formulario:

Modificar el código de acuerdo a lo siguiente:


Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As Sys-tem.EventArgs) Handles Button1.Click Dim n As Integer ' número Dim n1 As Integer 'variable auxiliar Dim qi, ri As Integer ' qi=cociente, ri=residuo Dim r As Integer ' r=residuo Dim nc As Integer = 0 'nc=numero de cifras del número Dim capicua As Boolean = True 'el numero es capicua n = TextBox1.Text 'contar el número de cifras del número n1 = n While (n1 <> 0) nc = nc + 1 n1 = n1 \ 10 End While 'verificar si es capicua nc = nc - 1 'exponente para obtener el cociente entero ri = n While (n <> 0) r = n Mod 10 'cifra de la derecha qi = ri \ (10 ^ nc) 'cifra de la izquierda If (r <> qi) Then capicua = False Exit While End If ri = ri Mod 10 ^ nc n = n \ 10 nc = nc - 1 End While If (capicua = True) Then TextBox2.Text = "numero capicua" Else TextBox2.Text = "numero no capicua" End If End Sub Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click TextBox1.Text = "" TextBox2.Text = "" End Sub Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button3.Click End End Sub


Ejemplo (3): Escribir un programa que permita calcular el MCD (Máximo común divisor) de dos números utilizan-do el algoritmo de Euclides.

Dividir n1 entre n2 hasta que el residuo sea cero, en-tonces el MCD es el ultimo valor de n2. Luego de cada división si el residuo es diferente de cero asigne n1=n2 y n2=r, antes de realizar la siguiente división.

MCD (60,36)=12

Número mayor (n1) 60 36 24

Número menor (n2) 36 24 12

Residuo (r) 24 12 0

Cociente (q) 1 1 2

Dado que r=0, se tiene que el MCD=12=n2.

MCD (70,12)=2

Número mayor (n1) 70 12 10

Número menor (n2) 12 10 2

Residuo (r) 10 2 0

Cociente (q) 5 1 5

Dado que r=0, se tiene que el MCD=2=n2.

Solución:


Modifique el código de acuerdo a lo siguiente:

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As Sys-tem.EventArgs) Handles Button1.Click Dim n1, n2 As Integer 'numero mayor y menor Dim r, q As Integer 'residuo y cociente Dim mcd As Integer 'máximo común divisor n1 = num1.Text n2 = num2.Text While (True) r = n1 Mod n2 If (r = 0) Then 'sale del while mcd = n2 Exit While 'n2 es mcd End If n1 = n2 n2 = r End While respmcd.Text = mcd End Sub Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click num1.Text = "" num2.Text = "" respmcd.Text = "" End Sub Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button3.Click End End Sub


CAPITULO CUATRO

MATRICES

Al utilizar matrices, puede utilizar el mismo nombre para hacer referencia a distintas variables gracias a la utiliza-ción de un número denominado índice o subíndice que permite distinguirlas. Las matrices pueden reducir y simplificar el código, permitiendo crear bucles que gestionan de forma efi-ciente cualquier número de elementos.

4.1. INFORMACIÓN GENERAL SOBRE LAS MATRICES Las matrices permiten hacer referencia a una serie de variables mediante un mismo nombre y utilizar un núme-ro, denominado índice o subíndice, para distinguirlas. De esta forma, se puede crear un código más simple y reducido en muchos casos, ya que es posible utilizar bucles que usen el índice para procesar eficientemente cualquier número de elementos de la matriz.

4.1.1. DIMENSIONES DE MATRIZ

Las matrices pueden tener una o varias dimen-siones. La dimensión (el rango) de la matriz corresponde al número de subíndices que se utilizan para identificar un elemento indivi-dual. Se pueden especificar hasta 32 dimen-siones, aunque no es habitual tener más de tres.


4.1.2. TAMAÑO DE MATRIZ

Cada dimensión de una matriz tiene una longi-tud distinta de cero. Los elementos de la ma-triz son contiguos en cada dimensión, desde 0 hasta el mayor valor del subíndice de esa di-mensión. Puesto que Visual Basic asigna espa-cio para todos los elementos de una matriz, se debe evitar declarar una matriz mayor de lo necesario.

Una matriz de longitud cero es una matriz sin elementos. A veces resulta necesario especi-ficar matrices de este tipo, por ejemplo al utilizar formularios Windows Forms. Para hacerlo, declare una de las dimensiones de la matriz como –1. La matriz estará vacía, pero existirá. En consecuencia, una variable que apunte a la matriz no será igual a Nothing.

Las matrices de Visual Basic no tienen un ta-maño fijo. Después de haber creado una ma-triz, se puede cambiar su tamaño. La instruc-ción ReDim asigna un objeto matriz completa-mente nuevo a la variable matriz especifica-da. Por consiguiente, ReDim puede cambiar la longitud de cada dimensión.

4.2. DECLARAR VARIABLES DE MATRIZ Las variables de matriz se declaran del mismo modo que otras variables, mediante la instrucción Dim. Se agre-gan uno o más pares de paréntesis a continuación del nombre de la variable para indicar que es una matriz en vez de un valor escalar (una variable que contiene un solo valor).

Para declarar una variable de matriz unidimensional

En la declaración, agregue un par de paréntesis detrás del nombre de la variable, tal y como muestra el si-guiente ejemplo:

Dim MySingleArray() As Integer

Para declarar una variable de matriz multidimensional

En la declaración, agregue un par de paréntesis detrás del nombre de la variable y coloque comas dentro de


los paréntesis para separar las dimensiones, tal y co-mo muestra el siguiente ejemplo:

Dim My4DArray(,,,) As Short

' Four-dimensional array.

Para declarar una variable de matriz escalonada

En la declaración, agregue tantos pares de paréntesis detrás del nombre de la variable como niveles de ma-trices anidadas haya, tal y como se ve en el siguiente ejemplo:

Dim MyJaggedArray()()() As Byte 'Array of arrays of Byte arrays.

4.2.1. INICIALIZAR MATRICES

Se puede inicializar una variable de matriz como parte de su propia declaración. Se puede realizar una de las siguientes acciones en la instrucción de declaración:

• Especificar la longitud inicial de una o más de las dimensiones entre paréntesis detrás del nombre de la variable, sin asignar un objeto de matriz a la varia-ble.

• Asignar un objeto de matriz a la varia-ble, mediante la cláusula New. Al utili-zar una cláusula New, ésta debe ir se-guida de llaves ({}), incluso si están vacías.

• Asignar un objeto matriz a la variable y suministrar las longitudes iniciales me-diante la cláusula New.

• Asignar un objeto matriz a la variable y suministrar los valores de elementos iniciales mediante la cláusula New. Pue-de suministrar ambas longitudes y valo-res en la misma cláusula New.

Si especifica longitudes de dimensión en los paréntesis detrás del nombre de la variable, debe utilizar una instrucción de asignación posterior para asignar un objeto de matriz a


la variable. En las siguientes declaraciones de ejemplo se muestra la sintaxis correcta e incorrecta para una variable de matriz unidi-mensional:

Dim BA(2) As Byte ' Currently contains Nothing (no object). Dim BA(2) As Byte = New Byte() ' INVALID (New after length specified). Dim BA() As Byte = New Byte() {} ' Empty Byte array object. Dim BA() As Byte = New Byte() ' INVALID (missing braces). Dim BA() As Byte = New Byte(2) ' INVALID (missing braces). Dim BA() As Byte = New Byte() {0,1,2} ' (0) through (2). Dim BA() As Byte = New Byte(2) {0,1,2} ' (0) through (2).

Una variable de matriz multidimensional se puede inicializar de forma similar. En las siguientes declaraciones de ejemplo se mues-tra una variable de matriz bidimensional de-clarada como una matriz de tipo Short con 2 filas y 2 columnas.

Dim S2X2(1, 1) As Short ' (0) through (1), (0) through (1). Dim S2X2(1, 1) As Short = New Short(,) ' INVALID (New after lengths). Dim S2X2(,) As Short = New Short(,) ' INVALID (missing braces). Dim S2X2(,) As Short = New Short(1, 1) ' INVALID (missing braces). Dim S2X2(,) As Short = New Short(,) {} ' Empty array object. Dim S2X2(,) As Short = New Short(1, 1) {} ' Elements have default value. Dim S2X2(,) As Short = New Short(,) {{5, 6}, {7, 8}} ' Four elements.

El primer argumento representa las filas; el segundo, las columnas. En las matrices de las declaraciones anteriores, los valores del ín-dice varían entre 0 y 1 tanto para las filas como para las columnas.

Al inicializar una variable de matriz escalo-nada, sólo puede especificar las longitudes de dimensión para la matriz del nivel supe-rior. En las siguientes declaraciones de ejemplo se muestra la sintaxis correcta e in-correcta para una matriz de matrices con ele-mentos de tipo Byte:

Dim JB(1)() As Byte ' Array of two arrays of Byte elements. Dim JB(1)(1) As Byte ' INVALID (can only specify top-level size). Dim JB(1)() As Byte = New Byte()() ' INVALID (New after lengths). Dim JB()() As Byte = {New Byte() {}, New Byte() {}} ' Empty arrays. Dim JB()() As Byte = {New Byte(1) {}, New Byte(1) {}} ' Default values. Dim JB()() As Byte = {New Byte() {5, 6}, New Byte() {7, 8}}


En la última de las declaraciones anteriores, JB se inicializa en dos elementos, JB(0) y JB(1), cada uno de los cuales se inicializa en una matriz de tipo Byte de dos elementos, la primera con los valores de los elementos 5 y 6 y la segunda con los elementos 7 y 8.

4.2.2. LÍMITES DE TAMAÑO DE MATRIZ

La longitud de cada dimensión de una matriz se limita al valor máximo del tipo de datos Long, el cual es (2 ^ 64) - 1. El límite de tamaño total de una matriz varía, según el sistema operativo y la cantidad de memoria disponible. El uso de una matriz que supere la cantidad de RAM disponible en el sistema será más lento, ya que las operaciones de lectura y escritura deberán realizarse en el disco.

Nota: Puesto que en Visual Basic .NET las ma-trices son objetos, es importante distinguir entre un objeto de matriz y una variable de matriz. Un objeto matriz, una vez creado, no cambia de tamaño o rango. Sin embargo, una variable de matriz puede recibir la asigna-ción de diferentes matrices de distintos ta-maños y rangos durante su existencia.

4.2.3. CAMBIAR EL TAMAÑO DE MATRICES

Una matriz se puede redimensionar en cual-quier momento asignando un objeto matriz di-ferente a la misma variable de matriz, me-diante ReDim o una instrucción de asignación estándar. El nuevo objeto matriz puede tener dimensiones diferentes e incluso distinto rango. Esto ayuda a administrar la memoria de forma más eficaz. Por ejemplo, es posible utilizar una matriz grande durante un tiempo reducido y, después, redimensionarla mediante ReDim a un tamaño menor. De este modo, se li-bera memoria que ya no se necesita.

Cuando se redimensiona una matriz mediante ReDim, normalmente se pierden los valores existentes. No obstante, se pueden conservar si se incluye la palabra clave Preserve en la instrucción ReDim. Por ejemplo, la siguiente


instrucción asigna una nueva matriz, inicia-liza sus elementos a partir de los elementos correspondientes de MyArray y asigna la nueva matriz a MyArray.

ReDim Preserve MyArray(10, 20)

En una matriz de varias dimensiones, cuando se utiliza Preserve, sólo se puede cambiar la última dimensión. Si se intenta cambiar cual-quiera de las otras dimensiones, se produce un error en tiempo de ejecución. Si no se co-noce el tamaño real de una dimensión, se pue-de utilizar el método GetUpperBound, que de-vuelve el valor de subíndice más alto de la dimensión especificada.

En el siguiente ejemplo, la primera línea es válida, pero no la segunda, ya que intenta cambiar la primera dimensión de las dos exis-tentes.

ReDim Preserve Matrix(Matrix.GetUpperBound(0), Matrix.GetUpperBound(1) + 10) ReDim Preserve Matrix(Matrix.GetUpperBound(0) + 10, Ma-trix.GetUpperBound(1))

4.3. USAR LAS MATRICES Las matrices son útiles para trabajar con un conjunto de valores del mismo tipo de datos. Una matriz es una única variable con varios compartimentos para almace-nar valores, mientras que una variable escalar (es de-cir, no matricial) sólo dispone de un compartimiento para almacenar un único valor. Se puede hacer referen-cia a la matriz como un todo si se desea hacer refe-rencia a todos los valores que contiene, o bien se puede hacer referencia a sus elementos individuales uno a uno.

Por ejemplo, para almacenar los gastos diarios para cada día del año, se puede crear una matriz con 366 elementos, en vez de declarar 366 variables. Cada ele-mento de la matriz contiene un valor, al cual se ob-tiene acceso mediante el índice del elemento. En el siguiente ejemplo se declara la variable de matriz Cu-rExpense, se inicializa de modo que contenga 366 ele-mentos y, a continuación, se asigna a cada elemento el valor inicial 20.


Dim CurExpense(365) As Decimal ' Allocates (0) through (365). Dim I As Integer For I = 0 to 365 CurExpense(I) = 20.00 Next I

Se pueden mezclar distintos tipos de datos en una ma-triz si se declara del tipo Object. En el siguiente ejemplo se almacena información de empleados en la va-riable de matriz EmployeeData.

Dim EmployeeData(3) As Object ' Allocates (0) through (3). EmployeeData(0) = "Ron Bendel" EmployeeData(1) = "4242 Maple Blvd" EmployeeData(2) = 48 EmployeeData(3) = "06-09-1953"

4.3.1. MATRICES MULTIDIMENSIONALES

En Visual Basic, se pueden declarar matrices de hasta 32 dimensiones. Por ejemplo, la si-guiente instrucción declara una matriz bidi-mensional con 5 filas y 10 columnas.

Dim Rectangle(4, 9) As Single ' (0) through (4), (0) through (9).

El número total de elementos es el producto de los tamaños de todas las dimensiones; en este caso, 50.

El rango de una matriz se guarda en su pro-piedad Rank y la longitud de cada dimensión se obtiene con el método GetLength. El valor más bajo de subíndice para una dimensión es siempre 0 y el más alto lo devuelve el método GetUpperBound. Tenga en cuenta que, el argu-mento que se pasa a GetLength y GetUpperBound (la dimensión para la que se desea obtener la longitud o el subíndice mayor) también se em-pieza a contar desde 0.

Nota Cuando se agregan dimensiones a una matriz, el espacio total necesario para la matriz aumenta considerablemente; por ello, debe utilizar las matrices multidimensionales y escalonadas con prudencia.

Se puede utilizar bucles For anidados para procesar matrices multidimensionales de forma


eficaz. Por ejemplo, las siguientes instruc-ciones inicializan todos los elementos de Ma-trixA con valores comprendidos entre 0 y 99, según sus posiciones en la matriz.

Dim I, J As Integer Dim MaxDim0, MaxDim1 As Integer ' Highest subscripts, not lengths. Dim MatrixA(9, 9) As Double MaxDim0 = MatrixA.GetUpperBound(0) ' Maximum for first dimension. MaxDim1 = MatrixA.GetUpperBound(1) ' Maximum for second dimension. For I = 0 To MaxDim0 For J = 0 To MaxDim1 MatrixA(I, J) = (I * 10) + J Next J Next I

Puede obtener el tamaño total de una matriz de cualquier rango a partir de su propiedad Length. Esto representa el número total de elementos que contiene actualmente la matriz, no el número de bytes que consumen en el al-macenamiento. En el ejemplo anterior, Ma-trixA.Length devolvería 100.

4.4. CARACTERÍSTICAS AVANZADAS DE LAS MATRICES

Es posible asignar el contenido de una matriz a otra, crear funciones que acepten y devuelvan matrices y crear propiedades que acepten y devuelvan matrices. En muchos casos, estas técnicas pueden mejorar el rendi-miento de la aplicación.

4.4.1. ASIGNACIÓN DE MATRICES

Puesto que las matrices son objetos, pueden utilizarse en instrucciones de asignación co-mo cualquier otro tipo de objeto. En la asig-nación de una matriz a otra, se aplican las siguientes reglas:

• El rango (número de dimensiones) de la matriz de destino debe coincidir con el de la matriz de origen.

• Siempre que los rangos de las dos matri-ces sean iguales, no es necesario que las dimensiones sean iguales. El número


de elementos de una dimensión dada puede cambiar durante la asignación.

• Ambas matrices deben tener elementos de tipo referencia o bien ambas matrices deben tener elementos de tipo valor.

• Si ambas matrices tienen elementos de tipo valor, los tipos de datos deben co-incidir exactamente.

• En cambio, si ambas matrices tienen ele-mentos de tipo referencia, debe existir una conversión de ampliación del tipo de elemento de origen al tipo de elemento de destino.

El compilador notifica un error si las reglas anteriores no se cumplen, por ejemplo, si un tipo de datos no se puede convertir o si los rangos no son iguales. Se puede incluir con-trol de errores en el código para comprobar si las matrices son compatibles antes de in-tentar realizar la asignación.

4.4.2. DEVOLVER UNA MATRIZ DESDE UNA FUNCIÓN

Una función puede devolver una matriz de va-lores. Por ejemplo, quizá se desee devolver una matriz de elementos de tipo Byte sin te-ner que realizar conversiones entre este tipo y el tipo string. En el siguiente ejemplo, el procedimiento Function ArrayFunction devuelve una matriz de bytes.

Dim B As Byte = CByte(54) ' Seed value for ArrayFunction argument. Dim I As Integer ' Loop counter for displaying returned values. Dim ReturnArray() As Byte ' To be set from ArrayFunction return. ReturnArray = ArrayFunction(B) For I = 0 To ReturnArray.GetUpperBound(0) ' Highest subscript. Debug.WriteLine("Byte " & I & ": " & ReturnArray(I)) Next I ' ... Public Function ArrayFunction(ByVal B As Byte) As Byte() Dim X(2) As Byte ' Allocates three elements. X(0) = B X(1) = B + B X(2) = B + CByte(200) Return X End Function


Después de ejecutar el ejemplo anterior, Re-turnArray apunta a una matriz de tres elemen-tos que contiene los valores de elemento asignados a la matriz X en ArrayFunction. En este ejemplo, ReturnArray debe tener el mismo tipo de elementos que la matriz devuelta por la función, ya que se trata de un tipo de va-lor (en este caso Byte). Si los tipos de ele-mentos de ReturnArray y ArrayFunction hubieran sido tipos de referencia, hubiera sido acep-table una conversión de ampliación.

4.5. EJEMPLO DEL USO DE ARREGLOS Y LISTBOX Programa que elige la categoría de un participante a un evento y que muestra el costo de inscripción que le corresponde

Solución:

Utilizaremos el siguiente formulario:

Modifique el código siguiente:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load Dim elements() As String = {"PONENTE", "PROFESIONAL", "ESTUDIANTE", "COLABORADOR"} Dim i As Integer For i = 0 To UBound(elements) Me.ListBox1.Items.Add(elements(i)) Next


End Sub Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click Select Case ListBox1.SelectedItem Case "PONENTE" TextBox1.Text = 0 Case "PROFESIONAL" TextBox1.Text = 150 Case "ESTUDIANTE" TextBox1.Text = 50 Case "COLABORADOR" TextBox1.Text = 10 End Select End Sub Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click TextBox1.Text = "" End Sub Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button3.Click End End Sub

La ejecución es:


CAPITULO CINCO

PROCEDIMIENTOS

5.1. PROCEDIMIENTOS SUB Un procedimiento Sub consiste en una serie de instruc-ciones de Visual Basic delimitadas por las instruccio-nes Sub y End. Cada vez que se llama a un procedimien-to, se ejecutan las instrucciones de éste, desde la primera instrucción ejecutable tras la instrucción Sub hasta la primera instrucción End Sub, Exit Sub o Re-turn que se encuentre.

Un procedimiento Sub ejecuta acciones, pero no devuel-ve ningún valor. Puede tomar argumentos, como constan-tes, variables o expresiones, que le pasa el código de llamada.

La sintaxis para declarar un procedimiento Sub es la siguiente:

[accessibility] Sub subname[(argumentlist)] ' Statements of the Sub procedure go here. End Sub

La accesibilidad puede ser Public, Protected, Friend, Protected Friend o Private.


Los procedimientos Sub pueden definirse en módulos, clases y estructuras. Son Public de forma predetermi-nada, lo que significa que se les puede llamar desde cualquier parte de una aplicación.

5.1.1. DECLARACIÓN DE ARGUMENTOS

Los argumentos de un procedimiento se decla-ran igual que las variables, especificando el nombre y el tipo de datos del argumento. Tam-bién puede especificarse el mecanismo que se va a utilizar para pasar el argumento, así como si se trata de un argumento opcional.

La sintaxis de los argumentos en una lista de argumentos es la siguiente:

[Optional] [ByVal|ByRef] [ParamArray] argumentname As datatype

Si el argumento es opcional, la declaración de éste debe contener también un valor prede-terminado, como se muestra a continuación:

Optional [ByVal|ByRef] argumentname As datatype = defaultvalue

5.1.2. SINTAXIS DE LLAMADA

Los procedimientos Sub se invocan de forma explícita, con una instrucción de llamada in-dependiente. No se les puede llamar utilizan-do su nombre en una expresión. La instrucción de llamada debe suministrar el valor de todos los argumentos que no sean opcionales, y debe incluir la lista de argumentos entre parénte-sis. Si no se proporcionan argumentos, se puede omitir el paréntesis. El uso de la pa-labra clave Call también es opcional.

La sintaxis para llamar a un procedimiento Sub es la siguiente:

[Call] subname[(argumentlist)]


5.2. RETURN (INSTRUCCIÓN) Devuelve el control al código que llamó a un procedi-miento Sub, Function o Property.

Return

O bien

Return expr

Donde:

expr

Se requiere en un procedimiento Function o en un pro-cedimiento Property que recupera el valor de la pro-piedad. Es una expresión que representa el valor que se devolverá al código de llamada.

Comentarios

Para un procedimiento Sub o un procedimiento Property que establece el valor de la propiedad, la instrucción Return equivale a una instrucción Exit Sub y no se de-be especificar exp.

Para un procedimiento Function o un procedimiento Pro-perty que recupera el valor de la propiedad, debe in-cluirse expr y debe evaluarse como un tipo de datos que sea convertible al tipo de la función. De esta forma, Return equivale a asignar la expresión al nom-bre de la función como valor devuelto y después ejecu-tar una instrucción Exit Function.

Ejemplo

En este ejemplo se utiliza varias veces la instrucción Return para regresar al código de llamada cuando el procedimiento ya no tiene que hacer nada más.

Public Function GetAgePhrase(Age As Integer) As String If Age > 60 Then Return "Senior" If Age > 40 Then Return "Middle-aged" If Age > 20 Then Return "Adult" If Age > 12 Then Return "Teen-aged" If Age > 4 Then Return "School-aged" If Age > 1 Then Return "Toddler" Return "Infant" End Function


5.3. PROCEDIMIENTOS FUNCTION Un procedimiento Function consiste en una serie de instrucciones de Visual Basic delimitadas por las ins-trucciones Function y End Function. Cada vez que se llama a un procedimiento de este tipo, se ejecutan las instrucciones de éste, desde la primera instrucción ejecutable tras la instrucción Function hasta la pri-mera instrucción End Function, Exit Function o Return que se encuentre.

Un procedimiento Function es similar a un procedimien-to Sub, pero además devuelve un valor al programa que realiza la llamada al procedimiento. Un procedimiento Function puede tomar argumentos, como constantes, va-riables o expresiones, que le pasa el código de llama-da.

La sintaxis para declarar un procedimiento Function es la siguiente:

[accessibility] Function functionname[(argumentlist)] As datatype ' Statements of the Function procedure. End Function

La accesibilidad puede ser Public, Protected, Friend, Protected Friend o Private.

Los procedimientos Function pueden definirse en módu-los, clases y estructuras. Son Public de forma prede-terminada, lo que significa que se les puede llamar desde cualquier parte de una aplicación.

Los argumentos se declaran del mismo modo que en un procedimiento Sub.

5.3.1. VALORES DEVUELTOS

El valor que un procedimiento Function de-vuelve al programa que realiza la llamada se denomina valor devuelto. La función puede de-volver dicho valor de dos maneras:

• La función asigna un valor a su propio nombre de función en una o más instruc-ciones del procedimiento. No se devuelve el control al programa que realiza la


llamada hasta que se ejecuta una ins-trucción Exit Function o End Function, como en el siguiente ejemplo:

Function functionname[(argumentlist)] As datatype ' ... functionname = expression 'Control remains within the function. ' ... End Function

• La función utiliza la instrucción Return para especificar el valor devuelto, e inmediatamente devuelve el control al programa de llamada, como en el siguien-te ejemplo:

Function functionname[(argumentlist)] As datatype ' ... Return expression 'Control is returned immediately. ' ... End Function

La ventaja de asignar el valor devuelto al nombre de la función es que el control perma-nece en la función hasta que el programa en-cuentra una instrucción Exit Function o End Función, lo que permite asignar un valor pre-vio y, si es necesario, se puede ajustar des-pués.

Si la función devuelve datos de tipo matri-cial, el acceso a los elementos individuales de la matriz no es posible dentro de la fun-ción. Si se intentara hacerlo, el compilador lo interpretará como una llamada a la fun-ción. En el siguiente ejemplo se generan errores de compilación:

Function AllOnes(ByVal N As Integer) As Integer() Dim I As Integer ' Singleton Integer, not Integer array. For I = 1 To N - 1 ' Assume N has a valid value. AllOnes(I) = 1 ' Compiler error: call with wrong data type. Next I Return AllOnes() ' Compiler error: call with no argument. End Function


Todos los procedimientos Function tienen un tipo de datos, al igual que las variables. La cláusula As de la instrucción Function espe-cifica el tipo de datos, y determina el tipo del valor devuelto. En las siguientes decla-raciones de ejemplo se ilustra esto último:

Function Yesterday As Date ' ... End Function Function FindSqrt(ByVal Number As Single) As Single ' ... End Function

5.3.2. SINTAXIS DE LLAMADA

Para llamar a un procedimiento Function, hay que incluir el nombre y los argumentos de és-te en la parte derecha de una asignación o en una expresión. Esto último se ilustra en los siguientes ejemplos de llamada:

lvalue = functionname[(argumentlist)] If ((functionname[(argumentlist)] / 3) <= expression) Then ...

El siguiente procedimiento Function calcula la hipotenusa de un triángulo rectángulo a partir de los valores de los catetos:

Function Hypotenuse (ByVal Side1 As Single, ByVal Side2 As Single) As Single Return Math.Sqrt((Side1 ^ 2) + (Side2 ^ 2)) End Function

Son llamadas habituales a Hypotenuse las si-guientes:

Dim TestLength, TestHypotenuse, X, Y, Area As Single TestHypotenuse = Hypotenuse(TestLength, 10.7) ' Assume TriangleArea is a defined Function procedure — the ' returned value from Hypotenuse is used as an argument to Tri-angleArea. Area = TriangleArea(X, Y, Hypotenuse(X, Y))

Common Language Runtime proporciona multitud de funciones, que se encuentran en el espacio de nombres Microsoft.VisualBasic. Entre las


funciones más comunes se encuentran, por ejemplo, Beep, MsgBox y StrComp. Puede llamar a estas funciones de la misma manera que lla-ma a los procedimientos Function que ha crea-do usted mismo.

Cuando se llama a un procedimiento Function, no es necesario utilizar su valor devuelto, en cuyo caso se ejecutan todas las acciones de la función, pero el valor devuelto se omi-te. Las llamadas a MsgBox suelen hacerse de esta manera.

5.4. FUNCIONES MATEMÁTICAS Requisitos

Class: Math (Clase)

Requisitos

Espacio de nombres: System.Math

Ensamblado: mscorlib (en mscorlib.dll)

Las funciones matemáticas de Visual Basic 6 han sido reemplazadas por métodos equivalentes en la clase Sys-tem.Math de .NET Framework.

Comentarios

Los métodos matemáticos de .NET Framework funcionan del mismo modo que sus equivalentes de Visual Basic 6, si bien algunos de sus nombres han sufrido ligeras di-ferencias. Así, por ejemplo, Atan es el equivalente en .NET Framework de la función Atn de Visual Basic 6. En la siguiente tabla se detallan los nombres de las fun-ciones matemáticas de Visual Basic 6 y sus métodos equivalentes en .NET Framework:


Función de Visual Basic 6

Método de Visual Basic .NET

Descripción

Abs Math.Abs (Método) Devuelve el valor absoluto de un núme-ro especificado.

Atn Math.Atan (Método) Devuelve un valor Double que contiene el ángulo cuya tan-gente es el número especificado.

Cos Math.Cos (Método) Devuelve un valor Double que contiene el coseno del ángulo especificado.

Exp Math.Exp (Método) Devuelve un valor Double que contiene "e" (base de los lo-garitmos naturales) elevado a la poten-cia especificada.

Log Math.Log (Método) Devuelve un valor Double que contiene el logaritmo del nú-mero especificado. Este método está so-brecargado y puede devolver o bien el logaritmo natural (de base e) del nú-mero especificado o bien el logaritmo del número especifi-cado en una base es-pecificada.

Round Math.Round (Método) Devuelve un valor de tipo Double que con-tiene el número más próximo al valor es-pecificado. Existen funciones de redon-deo adicionales dis-ponibles en forma de métodos de tipos in-trínsecos como Deci-mal.Round (Método).


Sgn Math.Sign (Método) Devuelve un valor Integer que indica el signo de un núme-ro.

Sin Math.Sin (Método) Devuelve un valor Double que especifi-ca el seno de un án-gulo.

Sqr Math.Sqrt (Método) Devuelve un valor Double que especifi-ca la raíz cuadrada de un número.

Tan Math.Tan (Método) Devuelve un valor Double que contiene la tangente de un ángulo.

Además, la clase matemática de .NET Framework ofrece constantes y otros métodos estáticos para funciones trigonométricas, logarítmicas y otras funciones mate-máticas habituales. Todo ello puede utilizarse en un programa de Visual Basic.

Para utilizar estas funciones sin calificación, impor-te el espacio de nombres System.Math a su proyecto agregando el siguiente código en la parte superior del código fuente:

Imports System.Math

Requisitos

Class: Math (Clase)

Ejemplo de Abs

En este ejemplo se utiliza el método Abs de la clase Math para calcular el valor absoluto de un número:

Imports System.Math ' Code will not compile unless placed within a Sub or Function Dim MyNumber As Double MyNumber = Abs(50.3) ' Returns 50.3. MyNumber = Abs(-50.3) ' Returns 50.3.


Ejemplo de Atan

En este ejemplo se utiliza el método Atan de la clase Math para calcular el valor de pi:

Imports System.Math ' Code will not compile unless placed within a Sub or Function Dim pi As Double pi = 4 * Atan(1) ' Calculate the value of pi.

Ejemplo de Cos

En este ejemplo se utiliza el método Cos de la clase Math para devolver el coseno de un ángulo:

Imports System.Math ' Code will not compile unless placed within a Sub or Function Dim MyAngle, MySecant As Double MyAngle = 1.3 ' Define angle in radians. MySecant = 1 / Cos(MyAngle) ' Calculate secant.

Ejemplo de Exp

En este ejemplo se utiliza el método Exp de la clase Math para devolver e elevado a una potencia:

Imports System.Math ' Code will not compile unless placed within a Sub or Function Dim MyAngle, MyHSin As Double ' Define angle in radians. MyAngle = 1.3 ' Calculate hyperbolic sine. MyHSin = (Exp(MyAngle) - Exp(-1 * MyAngle)) / 2

Ejemplo de Log

En este ejemplo se utiliza el método Log de la clase Math para devolver el logaritmo natural de un número:

Imports System.Math ' Code will not compile unless placed within a Sub or Function Dim MyAngle, MyLog As Double ' Define angle in radians. MyAngle = 1.3 ' Calculate inverse hyperbolic sine. MyLog = Log(MyAngle + Sqrt(MyAngle * MyAngle + 1))


Ejemplo de Round

En este ejemplo se utiliza el método Round de la clase Math para redondear un número al entero más próximo:

Imports System.Math ' Code will not compile unless placed within a Sub or Function Dim MyVar1 As Double = 2.8 Dim MyVar2 As Double MyVar2 =Round(MyVar1) ' Returns 3.

Ejemplo de Sign

En este ejemplo se utiliza el método Sign de la clase Math para determinar el signo de un número:

Imports System.Math ' Code will not compile unless placed within a Sub or Function Dim MyVar1, MyVar2, MyVar3 As Double Dim MySign As Integer MyVar1 = 12 MyVar2 = -2.4 MyVar3 = 0 MySign = Sign(MyVar1) ' Returns 1. MySign = Sign(MyVar2) ' Returns -1. MySign = Sign(MyVar3) ' Returns 0.

Ejemplo de Sin

En este ejemplo se utiliza el método Sin de la clase Math para devolver el seno de un ángulo:

Imports System.Math ' Code will not compile unless placed within a Sub or Function Dim MyAngle, MyCosecant As Double MyAngle = 1.3 ' Define angle in radians. MyCosecant = 1 / Sin(MyAngle) ' Calculate cosecant.

Ejemplo de Sqrt

En este ejemplo se utiliza el método Sqrt de la clase Math para calcular la raíz cuadrada de un número:

Imports System.Math ' Code will not compile unless placed within a Sub or Function Dim MySqr As Double MySqr = Sqrt(4) ' Returns 2. MySqr = Sqrt(23) ' Returns 4.79583152331272. MySqr = Sqrt(0) ' Returns 0. MySqr = Sqrt(-4) ' Returns NaN (not a number).


Ejemplo de Tan

En este ejemplo se utiliza el método Tan de la clase Math para devolver la tangente de un ángulo:

Imports System.Math ' Code will not compile unless placed within a Sub or Function Dim MyAngle, MyCotangent As Double MyAngle = 1.3 ' Define angle in radians. MyCotangent = 1 / Tan(MyAngle) ' Calculate cotangent.

5.5. EJEMPLO DEL USO DE SUB Y FUNCTION Ejemplo1:

Implementar un programa que permita elegir el cálculo del área de un rectángulo o de un círculo. Para calcu-lar el área del rectángulo utilice function y para calcular el área del círculo utilice sub. El programa debe solicitar sólo los datos que requiera el área a calcular.

Se pueden utilizar las siguientes entradas de datos:


Solución: Modifique el código de acuerdo a lo siguien-te:

Private Sub RadioButton1_CheckedChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles RadioButton1.CheckedChanged GroupBox2.Visible = True GroupBox3.Visible = False TextBox1.Text = "" TextBox2.Text = "" TextBox3.Text = "" TextBox4.Text = "" End Sub Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As Sys-tem.EventArgs) Handles MyBase.Load RadioButton1.Checked = True End Sub Private Sub RadioButton2_CheckedChanged(ByVal sender As Sys-tem.Object, ByVal e As System.EventArgs) Handles RadioBut-ton2.CheckedChanged GroupBox3.Visible = True GroupBox2.Visible = False TextBox1.Text = "" TextBox2.Text = "" TextBox3.Text = "" TextBox4.Text = "" End Sub


Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button3.Click End End Sub Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click Dim ra, area As Double If RadioButton1.Checked Then TextBox4.Text = rectangulo(TextBox1.Text, TextBox2.Text) End If If RadioButton2.Checked Then ra = TextBox3.Text circulo(ra, area) TextBox4.Text = area End If End Sub Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click TextBox1.Text = "" TextBox2.Text = "" TextBox3.Text = "" TextBox4.Text = "" End Sub Public Function rectangulo(ByVal b As Double, ByVal h As Double) As Double Return (b * h) End Function Public Sub circulo(ByVal r As Double, ByRef a As Double) a = Math.Pow(r, 2) * Math.PI End Sub

La ejecución del programa es:



CAPITULO SEIS

GRÁFICOS GDI+

Common Language Runtime usa una implementación avanzada de la interfaz de diseño de gráficos (GDI) de Windows, denominada GDI+, que permite crear gráficos, dibujar texto y manipular imágenes gráficas como si fueran objetos. La interfaz GDI+ está diseñada para ofrecer rendimiento a la vez que facilidad de uso. La interfaz GDI+ se puede utilizar para representar imágenes gráficas en formularios Windows Forms y en contro-les. GDI+ ha reemplazado completamente a GDI, y ahora es el único modo de representar gráficos mediante programa en apli-caciones de formularios Windows Forms. Asimismo, se puede usar el Editor de imágenes para crear imágenes en tiempo de diseño para su posterior utilización por parte de las aplica-ciones. A pesar de que no es posible usar la interfaz GDI+ directamente en los formularios Web Forms, se pueden mostrar imágenes gráficas mediante el control Image de servidor Web.

Los temas de esta sección presentan las nociones básicas de la programación con la interfaz GDI+. Aunque no pretende ser una referencia completa, esta sección incluye información so-bre los objetos Graphics, Pen, Brush y Color, y explica cómo realizar tareas tales como dibujar formas, dibujar texto o mostrar imágenes. Para obtener más información, vea el SDK de GDI+.


6.1. CREAR IMÁGENES GRÁFICAS CON GDI+ Antes de dibujar líneas y formas, representar texto o mostrar y manipular imágenes con GDI+, es preciso crear un objeto Graphics. El objeto Graphics represen-ta una superficie de dibujo de GDI+, y es el objeto que se usa para crear imágenes gráficas.

Para trabajar con gráficos existen los dos pasos si-guientes:

• Crear un objeto Graphics.

• Usar el objeto Graphics para dibujar líneas y for-mas, representar texto o mostrar y manipular imáge-nes.

6.1.1. CREAR UN OBJETO GRAPHICS

El objeto Graphics se puede crear de diversas formas:

• Mediante la recepción de una referencia a un objeto Graphics como parte de los argumentos PaintEventArgs del evento Paint de un formulario o control. Este es el modo en que normalmente se obtiene una referencia a un objeto Graphics cuando se crea código de dibujo para un control.

• Llamando al método CreateGraphics de un control o formulario para obtener una referencia a un objeto Graphics que re-presente la superficie de dibujo de di-cho control o formulario. Este es el mé-todo que se usa si se desea dibujar en un formulario o control que ya existía con anterioridad.

• Mediante la creación de un objeto Grap-hics a partir de cualquier objeto que herede de la clase Image. Este método resulta útil cuando se desea alterar una imagen que ya existe.


6.1.2. PAINTEVENTARGS EN EL CONTROLADOR DE EVENTOS PAINT

Cuando se programa el controlador de eventos Paint para controles, se proporciona un obje-to Graphics como uno de los argumentos Pain-tEventArgs.

Para obtener una referencia a un objeto Grap-hics a partir de PaintEventArgs en el evento Paint

• Declare el objeto Graphics.

• Asigne la variable que hará referencia al objeto Graphics y que se pasará como parte de PaintEventArgs.

• Inserte código para dibujar en el formu-lario o control.

El ejemplo siguiente muestra cómo hacer refe-rencia a un objeto Graphics a partir de Pain-tEventArgs en el evento Paint.

' Visual Basic Private Sub Form1_Paint(sender As Object, pe As PaintEventArgs) Handles _ MyBase.Paint ' Declares the Graphics object and sets it to the Graphics object ' supplied in the PaintEventArgs. Dim g As Graphics = pe.Graphics ' Insert code to paint the form here. End Sub

6.1.3. CREATEGRAPHICS (MÉTODO)

Asimismo, se puede utilizar el método Create-Graphics de un control o formulario para ob-tener una referencia a un objeto Graphics que represente la superficie de dibujo de dicho control o formulario.

Para crear un objeto Graphics con el método CreateGraphics

• Invoque al método CreateGraphics del formulario o control en el que desee re-presentar gráficos.

' Visual Basic


Dim g as Graphics ' Sets g to a Graphics object representing the drawing surface of the ' control or form g is a member of. g = Me.CreateGraphics

6.1.4. CREAR UN OBJETO GRAPHICS A PARTIR DE UN OBJETO IMAGE

Además, se puede crear un objeto Graphics a partir de cualquier objeto que se derive de la clase Image.

Para crear un objeto Graphics a partir de un objeto Image

• Invoque al método Graphics.FromImage, suministrando el nombre de la variable Image a partir de la cual desea crear un objeto Graphics.

El ejemplo siguiente muestra cómo usar un ob-jeto Bitmap:

' Visual Basic Dim myBitmap as New Bitmap("C:\Documents and Set-tings\Joe\Pics\myPic.bmp") Dim g as Graphics = Graphics.FromImage(myBitmap)

Nota Puede crear objetos Graphics a partir de archi-vos .bmp no indizados, como archivos .bmp de 16 bits, 24 bits y 32 bits. Cada píxel de archivos .bmp no in-dizados alberga un color, a diferencia de los píxeles de archivos .bmp indizados, que albergan un índice que hace referencia a una tabla de colores.

6.2. DIBUJAR Y MANIPULAR FORMAS E IMÁGENES Una vez creado el objeto Graphics, éste se puede usar para dibujar líneas y formas, representar texto o mos-trar y manipular imágenes. Los objetos principales que se usan con el objeto Graphics son:

• Pen (Clase): se utiliza para dibujar líneas y con-tornos de formas, o para representar otros elementos geométricos.

• Brush (Clase): se utiliza para rellenar áreas de los gráficos, tales como formas rellenas, imágenes o texto.


• Font (Clase): proporciona una descripción de las formas que se deben usar cuando se representa texto.

• Color (Estructura): representa los distintos colores que se mostrarán.

6.2.1. DIBUJAR LÍNEAS Y FORMAS CON GDI+

El objeto Graphics proporciona métodos para dibujar diversos tipos de líneas y formas. Las formas simples y complejas pueden repre-sentarse en colores sólidos o transparentes, o mediante texturas compuestas por gradientes definidos por el usuario o por imágenes. Las líneas, curvas abiertas y el contorno de las formas se crean con un objeto Pen. Para re-llenar una área, como un rectángulo o una curva cerrada, se requiere un objeto Brush.

Para dibujar una línea o el contorno de una forma

• Obtenga una referencia al objeto Grap-hics que usará para dibujar. Para obte-ner más información

' Visual Basic ' Obtains a reference to the graphics object for Button1. Dim g as Graphics = Me.CreateGraphics

• Cree una instancia de la clase Pen que desee usar para dibujar la línea y esta-blezca las propiedades necesarias.

' Visual Basic Dim myPen as new Pen(Color.Red) myPen.Width = 5

• Invoque al método apropiado para la for-ma que desee dibujar, suministrando cualquier parámetro necesario. La tabla siguiente muestra unos cuantos de los métodos más comunes. Para obtener una lista completa, vea Graphics (Métodos).


Método Forma

Método Graphics.DrawLine Línea; requiere coordenadas para indicar los puntos de inicio y fi-nal.

' Visual Basic g.DrawLine(myPen, 1, 1, 45, 65)

Para dibujar una forma rellena

• Obtenga una referencia al objeto Grap-hics que usará para dibujar.

Dim g as Graphics = Me.CreateGraphics

• Cree una instancia de la clase Brush que desee usar para pintar la forma.

Dim myBrush as New SolidBrush(Color.Red)

• Invoque al método apropiado para la for-ma que desee pintar, suministrando cual-quier parámetro necesario. Para algunos métodos, como FillPolygon, tendrá que suministrar una matriz de puntos que describan el contorno de la forma que desee pintar. Otros métodos, como Fill-Rectangle o FillPath, requieren un obje-to que describa el área que se va a re-llenar.

g.FillRectangle(myBrush, 50, 50, 100, 100)

6.3. EJEMPLO 1 DEL USO DE GRAFICOS GDI+ Realice un programa para mostrar la siguiente salida:


Solución:

Crear el formulario siguiente

Modificar el código donde sea necesario.

Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As Sys-tem.EventArgs) Handles Button2.Click


Dim g As Graphics = Me.CreateGraphics Dim myPen As New Pen(Color.Blue) myPen.Width = 5 g.DrawLine(myPen, 1, 1, 145, 165) End Sub Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button3.Click ' Visual Basic Dim g As Graphics = Me.CreateGraphics Dim myBrush As New SolidBrush(Color.Red) g.FillRectangle(myBrush, 30, 40, 120, 130)

End Sub

La salida después de la pulsación de los botones es:

6.4. GRAPHICS (MÉTODOS DE)

A continuación se enumeran los métodos de la clase Graphics.


Métodos públicos

AddMetafileComment Agrega un comentario al objeto Metafile actual.

BeginContainer Sobrecargado. Guarda un conte-nedor de gráficos con el esta-do actual de este objeto Graphics y abre y utiliza un nuevo contenedor de gráficos.

Clear

Compatible con .NET Compact Framework.

Borra toda la superficie de dibujo y la rellena con el co-lor de fondo especificado.

CreateObjRef (se hereda de MarshalByRefObject)

Crea un objeto que contiene toda la información relevante necesaria para generar un proxy utilizado para comuni-carse con un objeto remoto.

Dispose


Libera todos los recursos uti-lizados por este objeto Graphics.

DrawArc Sobrecargado. Dibuja un archi-vo que representa una parte de una elipse especificada por un par de coordenadas, un valor de ancho y un valor de alto.

DrawBezier Sobrecargado. Dibuja una curva spline de Bézier definida por cuatro estructuras Point.

DrawBeziers Sobrecargado. Dibuja una serie de curvas spline de Bézier a partir de una matriz de es-tructuras Point.

DrawClosedCurve Sobrecargado. Dibuja una curva spline cardinal cerrada, defi-nida por una matriz de estruc-turas Point.

DrawCurve Sobrecargado. Dibuja una curva spline cardinal a través de una matriz especificada de es-tructuras Point.

DrawEllipse


Sobrecargado. Dibuja una elip-se definida por un rectángulo delimitador especificado por un par de coordenadas, un va-lor de alto y un valor de an-cho.


DrawIcon


Sobrecargado. Dibuja la imagen representada por el objeto Icon especificado en las coor-denadas señaladas.

DrawIconUnstretched Dibuja la imagen representada por el objeto Icon especifica-do sin transformar a escala la imagen.

DrawImage


Sobrecargado. Dibuja el objeto Image especificado en la ubi-cación especificada y con el tamaño original.

DrawImageUnscaled Sobrecargado. Dibuja la imagen especificada con su tamaño fí-sico original y en la ubica-ción especificada por un par de coordenadas.

DrawLine


Sobrecargado. Dibuja una línea que conecta los dos puntos es-pecificados por los pares de coordenadas.

DrawLines Sobrecargado. Dibuja una serie de segmentos de línea que co-nectan una matriz de estructu-ras Point.

DrawPath Dibuja un objeto GraphicsPath.

DrawPie Sobrecargado. Dibuja una forma circular definida por una elipse y determinada por un par de coordenadas, unos valo-res de ancho y alto y dos lí-neas radiales.

DrawPolygon


Sobrecargado. Dibuja un polí-gono definido por una matriz de estructuras Point.

DrawRectangle


Sobrecargado. Dibuja un rec-tángulo especificado por un par de coordenadas, un valor de ancho y un valor de alto.

DrawRectangles Sobrecargado. Dibuja una serie de rectángulos especificados por las estructuras Rectangle.

DrawString Sobrecargado. Dibuja la cadena de texto especificada en la


Compatible con .NET Compact Framework. ubicación especificada y con los objetos Brush y Font espe-cificados.

EndContainer Cierra el contenedor de gráfi-cos actual y restaura el esta-do que tenía este objeto Graphics al estado guardado mediante una llamada al método BeginContainer.

EnumerateMetafile Sobrecargado. Envía los regis-tros del objeto Metafile espe-cificado, de uno en uno, a un método de devolución de llama-da para su presentación en un punto determinado.

Equals (se hereda de Ob-ject)


Sobrecargado. Determina si dos instancias de Object son igua-les.

ExcludeClip Sobrecargado. Actualiza la re-gión de recorte de este objeto Graphics con el fin de excluir el área especificada por una estructura Rectangle.

FillClosedCurve Sobrecargado. Rellena el in-terior de una curva spline cardinal cerrada, definida por una matriz de estructuras Point.

FillEllipse


Sobrecargado. Rellena el in-terior de una elipse definida por un rectángulo de delimita-ción especificado por un par de coordenadas, un valor de alto y un valor de ancho.

FillPath Rellena el interior de un ob-jeto GraphicsPath.

FillPie Sobrecargado. Rellena el in-terior de una sección de grá-fico circular definida por una elipse, determinada por un par de coordenadas, unos valores de ancho y alto y dos líneas radiales.

FillPolygon Sobrecargado. Rellena el in-terior de un polígono definido


Compatible con .NET Compact Framework. por una matriz de puntos, es-pecificados por estructuras Point.

FillRectangle


Sobrecargado. Rellena el in-terior de un rectángulo espe-cificado por un par de coorde-nadas, un valor de ancho y un valor de alto.

FillRectangles Sobrecargado. Rellena el in-terior de una serie de rectán-gulos especificados por es-tructuras Rectangle.

FillRegion


Rellena el interior de un ob-jeto Region.

Flush Sobrecargado. Fuerza la ejecu-ción de todas las operaciones de gráficos pendientes y de-vuelve inmediatamente el con-trol sin esperar a que finali-cen las operaciones.

FromHdc Sobrecargado. Crea un nuevo objeto Graphics a partir del identificador especificado en un contexto de dispositivo.

FromHdcInternal Método interno. No utilizar.

FromHwnd Crea un nuevo objeto Graphics a partir del identificador es-pecificado de una ventana.

FromHwndInternal Método interno. No utilizar.

FromImage


Crea un nuevo objeto Graphics a partir del objeto Image es-pecificado.

GetHalftonePalette Obtiene un identificador de la paleta actual de medios tonos de Windows.

GetHashCode (se hereda de Object)


Sirve como función hash para un tipo concreto, apropiado para su utilización en algo-ritmos de hash y estructuras de datos como las tablas hash.


GetHdc Obtiene el identificador del contexto de dispositivo aso-ciado a este objeto Graphics.

GetLifetimeService (se hereda de MarshalByRefObject)

Recupera el objeto de servicio de duración actual que contro-la la directiva de duración de esta instancia.

GetNearestColor Obtiene el color más próximo a la estructura Color especifi-cada.

GetType (se hereda de Ob-ject)


Obtiene el objeto Type de la instancia actual.

InitializeLifetimeService (se hereda de MarshalByRefOb-ject)

Obtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia.

IntersectClip Sobrecargado. Actualiza la re-gión de recorte del objeto Graphics como la intersección de la región de recorte actual y la estructura Rectangle es-pecificada.

IsVisible Sobrecargado. Indica si el punto especificado por un par de coordenadas se halla conte-nido en la región de recorte visible de este objeto Graphics.

MeasureCharacterRanges Obtiene una matriz de objetos Region, cada uno de los cuales delimita un intervalo de posi-ciones de caracteres dentro de la cadena especificada.

MeasureString


Sobrecargado. Mide la cadena especificada al dibujarla con el objeto Font especificado.

MultiplyTransform Sobrecargado. Multiplica la transformación universal del objeto Graphics y especificada en el objeto Matrix.

ReleaseHdc Libera un identificador de contexto de dispositivo obte-nido mediante una llamada an-


terior al método GetHdc de es-te objeto Graphics.

ReleaseHdcInternal Método interno. No utilizar.

ResetClip


Restablece la región de recor-te de este objeto Graphics en una región infinita.

ResetTransform Restablece la matriz de trans-formación universal de este objeto Graphics en la matriz de identidades.

Restore Restaura como estado de este objeto Graphics el estado re-presentado por un objeto GraphicsState.

RotateTransform Sobrecargado. Aplica la rota-ción especificada a la matriz de transformación de este ob-jeto Graphics.

Save Guarda el estado actual de es-te objeto Graphics e identifi-ca el estado guardado con un objeto GraphicsState.

ScaleTransform Sobrecargado. Aplica la opera-ción de cambio de escala espe-cificada a la matriz de trans-formación de este objeto Graphics, anteponiéndola a es-ta última.

SetClip Sobrecargado. Establece la re-gión de recorte de este objeto Graphics en la propiedad Clip del objeto Graphics especifi-cado.

ToString (se hereda de Ob-ject)


Devuelve un objeto String que representa al objeto Object actual.

TransformPoints Sobrecargado. Transforma una matriz de puntos de un espacio de coordenadas a otro utili-zando las transformaciones universal y de página actuales de este objeto Graphics.


TranslateClip Sobrecargado. Convierte la re-gión de recorte de este objeto Graphics usando las cantidades especificadas en las direccio-nes horizontal y vertical.

TranslateTransform Sobrecargado. Antepone la con-versión especificada a la ma-triz de transformación de este objeto Graphics.

Métodos protegidos

Finalize


Reemplazado. Vea Object.Finalize.

En C# y C++, los finalizadores se expresan mediante la sintaxis del destructor.

MemberwiseClone (se hereda de Object)


Crea una copia superficial del objeto Object actual.


BIBLIOGRAFIA

1. Bembey, Pooja y Kaur Kuljit (2002). “Proyectos profesionales Visual Basic .NET”. Edi-

torial Anaya Multimedia. España. 2. Dobson, Rick (2002). “Programación de Microsoft Sql Server 2000 con Microsoft Visual

Basic .NET”. Editorial McGrawHill. España. 3. Evjen, Bill y Beres, Jason (2002). “El libro de Microsoft Visual Basic .NET”. Editorial

Anaya Multimedia. España. 4. Francia Huambachano, Dario (2003). “Desarrollo de aplicaciones ASP.NET”. Editorial

Macro. Lima, Perú. 5. Heredia Mayer, Juan Carlos (2004). “Aplicaciones y Servicios Web con ASP.Net y SQL

Server 2000”. Editorial GrapPeru SAC. Lima, Perú. 6. Microsoft: MSDN training (2002). “2310B: Developing Microsoft ASP .NET, Web Appli-

cations Using Visual Studio .NET”. Microsoft Corporation. Colombia. 7. Microsoft: MSDN training (2002). “2565A: Developing Microsoft .NET, Applications for

windows (Visual Basic .NET)”. Microsoft Corporation. Colombia. 8. Serrano Perez, Jorge (2002). “Programación con ASP .NET”. Editorial Anaya Multime-

dia. España.


INDICE ALFABETICO

. .NET Framework, 3

C Common Language Runtime, 6 comparar cadenas, 22 comparar valores, 21

D Do...Loop, 39

E ESTRUCTURAS DE CONTROL, 29

F For...Next, 40 Funciones matemáticas, 65

G GDI, 75

Crear imágenes, 76 Dibujar líneas y formas, 79

I Identificadores, 14 If...Then...Else, 29 interfaz de diseño de gráficos, 75

M Matrices, 47

Cambiar el tamaño, 51 dimensiones, 47 inicializar, 49

Matrices multidimensionales, 53

O operaciones aritméticas, 19 operadores aritméticos, 19 operadores de comparación, 20 operadores de concatenación, 24 operadores lógicos, 25

P Preserve, 52 Procedimientos Function, 62 PROCEDIMIENTOS SUB, 59

R ReDim, 51 Return, 61

S Select...Case, 35

T tipos de datos de Visual Basic .NET, 11

V variable, 14

accesibilidad, 17 ámbito, 16 declaración, 14 local, 15 período de duración, 16

variables de matriz, 48 Visual Studio .NET, 3

W While...End While, 38
