Conociendo todo

Visual Basic 2010

Net Framework 4.0
[Link] 4.0
Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0
Autor: Cristian Sánchez Flores

© Derecho de autor reservado

Empresa Editora Macro E.I.R.L.

© Derecho de edición, arte gráfico y diagramación reservados

Empresa Editora Macro E.I.R.L.

Edición a cargo de:

Empresa Editora Macro E.I.R.L.
Av. Paseo de la República 5613 - Miraflores
Lima - Perú
( (511) 719-9700
* ventas@[Link]
[Link]

Primera edición: Octubre 2011 - 1000 ejemplares

Impreso en los Talleres Gráficos de

Empresa Editora Macro E.I.R.L.
Lima - Perú

ISBN Nº 978-612-304-026-0
Hecho el Depósito Legal en la Biblioteca Nacional del Perú Nº 2011-12580

Prohibida la reproducción parcial o total, por cualquier medio o método de este libro sin previa
autorización de la Empresa Editora Macro E.I.R.L.
 Cristian Sanchez Flores

Trainer Oficial de Certificaciónes Microsoft de la Universidad Nacional de Ingeniería, cuenta con las
siguientes certificaciones MCP, MCTS Windows Application y Web Application, MCPD Web Application
y MCT.

Profesor de las Cursos Libres de la Universidad del Callao, Facultad de Ingeniería, Profesor de la
Universidad Particular Cesar Vallejo, Docente de Instituto San Ignacio de Loyola y Profesor de los
Cursos de Titulación (SIDET) de IDAT

Desarrollo proyectos con empresas tales como el Banco Financiero, PRONAA, Banco Sudamericano,
ESSALUD, Clínica Maison de Sante, Banco de la Nación, Banco Central de Reservas, Wester Union,
ha sido Jefe de Desarrollo de la Caja Metropolitana de Lima, Jefe de Sistemas de la Charles Chaplin,
actualmente es Sub Gerente de Desarrollo y TIC´S de la Municipalidad de los Olivos.

Consultor de Sistemas, con amplia experiencia en el desarrollo de aplicaciones financieras, con

especialización en aplicaciones Web. Es también difusor de Tecnologías Microsoft a través de eventos
en comunidades de usuarios.
 Agradecimientos
Este Libro se lo dedico a Dios por bendecirme día
a día.
A Lili, Fátima y André, por ser las personas más
especiales del mundo a los cuales las amo.
A mis padres, porque todo el esfuerzo que hicieron
por mi.
A la Palma, el equipo de mi barrio, del único equipo
que es mi debilidad, del cual soy hincha desde que
nací.
 Prólogo
Permitir al participante conocer las diferentes técnicas para desarrollar soluciones que accedan a
datos y que vienen incluidas dentro de la versión 4.0 de [Link], tal que puedan resolver diferentes
escenarios de negocios empleando la tecnología apropiada, acorde a las necesidades del sistema a
desarrollar. Se tratan en el curso tecnologías clave como [Link] Entity Framework, LINQ (Language
Integrated Query).

Después de completado el curso los participantes estarán en condiciones de: Evaluar casos de
negocios y seleccionar la combinación apropiada de tecnologías de acceso a datos, y herramientas
para cada caso. Usar las herramientas que el Entity Framework proporciona para mapear el modelo
conceptual que la lógica de aplicación usa con el modelo de datos lógico que la base de datos
proporciona. Consultar y dar mantenimiento en un Entity Data Model (EDM) usando métodos
comunes tales como LINQ to Entities, Entity SQL y las clases del namespace EntityClient. Describir las
mejores prácticas para diseñar y construir una capa de datos escalable y optimizada usando Object
Services. Construir soluciones extensibles y atender los problemas de arquitectura que pueden
producirse cuando se construye una aplicación empresarial.
 Índice
Capítulo 1: Net Framework 4.0
Que es Net Framework ................................................................................................................................. 17
Novedades del Framework 4.0...................................................................................................................... 17
Composición del Framework ......................................................................................................................... 19
Componentes del Framework 4.0 ............................................................................................................ 20
1. Runtime del lenguaje común ................................................................................................................... 20
2. Biblioteca de clases .................................................................................................................................. 21
3. CLS y lenguajes ......................................................................................................................................... 22
Arquitectura de .NET Framework 4.0 ............................................................................................................ 23
Relación entre las versiones 2.0, 3.0, 3.5 y 4.0 del Framework ..................................................................... 24
Versiones de Visual Studio 2010 .............................................................................................................. 26
Windows Presentation Foundation .............................................................................................................. 26
¿El por qué de WPF? ..................................................................................................................................... 27
Windows Communication Foundation ......................................................................................................... 28
Windows Workflow Foundation .................................................................................................................... 29
Que es WorkFlow? ........................................................................................................................................ 29
Lo nuevo en Visual Studio 2010 ............................................................................................................... 30

Capítulo 2: Aprendiendo a conocer Visual Studio 2010

Fundamentos de Programación ............................................................................................................... 37
Conceptos básicos ......................................................................................................................................... 37
Clases / Objetos ............................................................................................................................................ 37
Programación Orientada a Objetos (OOP / PPO) .......................................................................................... 37
Herencia ........................................................................................................................................................ 37
Encapsulación ............................................................................................................................................... 37
Polimorfismo ................................................................................................................................................. 37
Interface ....................................................................................................................................................... 37
Clases abstractas .......................................................................................................................................... 37
Interface / Implements.................................................................................................................................. 38
Método ......................................................................................................................................................... 38
Sub ................................................................................................................................................................ 38
Parámetro ..................................................................................................................................................... 38
Parámetros opcionales ................................................................................................................................. 38
Variable ......................................................................................................................................................... 38
Constante ...................................................................................................................................................... 39
Evento ........................................................................................................................................................... 39
Handles ......................................................................................................................................................... 39
Sobrecarga (Overload) .................................................................................................................................. 39
Formulario (ventana) .................................................................................................................................... 39
MyBase ......................................................................................................................................................... 39
Me (this) ........................................................................................................................................................ 39
Colecciones ................................................................................................................................................... 39
Expresiones ................................................................................................................................................... 39
 Expresiones Lógicas ...................................................................................................................................... 40
Módulo.......................................................................................................................................................... 40
Instancia........................................................................................................................................................ 40
Enumeraciones (Enum) ................................................................................................................................. 40
Array (matrices) ............................................................................................................................................ 40
Common Language Runtime (CLR) ............................................................................................................... 40
Soluciones, Aplicaciones y Proyectos ...................................................................................................... 40
Archivos de proyectos y soluciones .............................................................................................................. 40
Aplicaciones de Consola ................................................................................................................................ 41
Tipos, Variables y Estructuras de Control ...................................................................................................... 43
Ámbitos y Visibilidad ..................................................................................................................................... 46
Programación Orientada a Objetos – POO ................................................................................................... 48
Clases en .NET ............................................................................................................................................... 51
Object: La clase base de todas las clases de .NET ......................................................................................... 52
Definir una Clase ........................................................................................................................................... 52
Ventana de Propiedades .......................................................................................................................... 68

Capítulo 3: Estructuras de Control Condicionales

Estructuras de Control, Condicionales. .................................................................................................... 83
Sentencia de Control – if…then…else ............................................................................................................ 83
Estructuras de Repetición por Contador ....................................................................................................... 90
Funciones de Conversión en Visual Basic ...................................................................................................... 98
Ejemplos de funciones de conversión ........................................................................................................... 99
Funciones de Conversión ........................................................................................................................ 102
Funcion Messagebox .................................................................................................................................... 103
Funciones de comprobación de tipos de datos ............................................................................................. 109
Funciones de Cadena de Caracteres ............................................................................................................. 111
Funciones de Fecha y hora ............................................................................................................................ 112
Funciones, Sub Rutinas y Procedimientos ............................................................................................... 115
Creación de Procedimientos Sobre Cargados .......................................................................................... 116
Llamada a un Procedimiento o Función Sobre Cargado:.............................................................................. 116
Cómo utilizar argumentos opcionales en un procedimiento o función ......................................................... 116
Como Declarar un argumento opcional ....................................................................................................... 117

Capítulo 4: Programación Avanzada en Visual Studio 2010

Manejo de excepciones ................................................................................................................................. 129
¿Qué es una excepción? ............................................................................................................................... 131
La clase Exception ......................................................................................................................................... 131
Try ................................................................................................................................................................. 131
Catch ............................................................................................................................................................. 131
Finally ............................................................................................................................................................ 132
Validación de Controles................................................................................................................................. 133
Delegados ................................................................................................................................................ 142
Eventos .......................................................................................................................................................... 142
Qué es Un Evento .......................................................................................................................................... 142
Propiedades de los controles ........................................................................................................................ 143
 Definición e implementación de delegados .................................................................................................. 143
Los delegados y el operador AddressOf ........................................................................................................ 146
Creando un Explorador ................................................................................................................................. 148
Trabajando con el Control ListView.......................................................................................................... 153
Servicios de Windows .............................................................................................................................. 155

Capítulo 5: Menus, Forms Avanzados e Hilos

Trabajando con Menus y Formularios Avanzados.................................................................................... 165
Creación de Formularios MDI........................................................................................................................ 165
Uso del control MenuStrip ............................................................................................................................ 165
Agregando elementos predefinidos .............................................................................................................. 166
Cuadro de Opciones para Mantenimiento de un MenuStrip......................................................................... 167
Miembros importantes del control MenuStrip .............................................................................................. 167
Uso del control ToolStrip ............................................................................................................................... 168
Uso del Control StatusStrip ........................................................................................................................... 170
Trabajando con Hilos (Threading) ............................................................................................................ 175
Definición ...................................................................................................................................................... 175
La clase Thread ............................................................................................................................................. 176
Constructores públicos .................................................................................................................................. 176
Propiedades públicas .................................................................................................................................... 176
Métodos públicos .......................................................................................................................................... 177
Métodos protegidos ...................................................................................................................................... 178
Tabla Propiedades Hilos ................................................................................................................................ 179
Tipos de Formas de Trabajar los HILOS ......................................................................................................... 181
Locking .......................................................................................................................................................... 181
Signaling ....................................................................................................................................................... 181
Interlocking ................................................................................................................................................... 182

Capítulo 6: Trabajando con Archivos y Gráficos en Visual Studio 2010

Manejo de Archivos y Directorios ............................................................................................................ 195
¿Que son la clase FileSystem? ...................................................................................................................... 195
Cómo enumerar archivos en un directorio .................................................................................................... 196
Lectura y Escritura sobre Archivos ................................................................................................................ 196
Como Escribir en un Archivo ......................................................................................................................... 197
Otra Forma de Trabajar con Archivos ........................................................................................................... 198
Abriendo un Archivo de Entrada y Salida: ..................................................................................................... 198
Cuadros de Dialogo .................................................................................................................................. 202
Graficos en Visual Studio 2010 ................................................................................................................ 206
Trabajando con Graficas en .NET. ................................................................................................................. 206

Capítulo 7: Collection and Generics NameSpaces y Bibliotecas de Clases

Mensajes y Creación de Matrices ............................................................................................................ 219
Colecciones en .NET Framework ............................................................................................................. 220
Clase ArrayLIst .................................................................................................................................... 221
Clases [Link].............................................................................................................................. 224
Clases [Link] y [Link] ................................................ 224
 Colecciones Genéricas ................................................................................................................................... 224
Cuándo utilizar colecciones genéricas ........................................................................................................... 227
Tipos adicionales ........................................................................................................................................... 227
Funcionalidad adicional ................................................................................................................................ 227
Qué son Genericos ................................................................................................................................... 230
Bibliotecas de Clases de funciones en Visual Basic .net........................................................................... 236
La clase Math ................................................................................................................................................ 236
Campos públicos ........................................................................................................................................... 236
Métodos públicos .......................................................................................................................................... 236
La clase Array ................................................................................................................................................ 237
Propiedades públicas .................................................................................................................................... 237
Métodos públicos .......................................................................................................................................... 237
Métodos protegidos ...................................................................................................................................... 238
Implementaciones de interfaces explícitas.................................................................................................... 238
La clase String ............................................................................................................................................... 239
Constructores públicos .................................................................................................................................. 239
Campos públicos ........................................................................................................................................... 239
Propiedades públicas .................................................................................................................................... 239
Métodos públicos .......................................................................................................................................... 239

Capítulo 8: Serialización y Servicios Windows

Serializacion ............................................................................................................................................. 243
Conceptos...................................................................................................................................................... 243
Definiciones Genéricas .................................................................................................................................. 243
Otras definiciones ......................................................................................................................................... 243
¿Cómo son los objetos serializados utilizando BinaryFormatter y SoapFormatter? ...................................... 245
Serialización en formato Binario ................................................................................................................... 245
Serialización XML ..................................................................................................................................... 249
La clase SoapFormatter: ............................................................................................................................... 249
Propiedades de los Controles del Formulario ................................................................................................ 253
¿Cuáles son los atributos serialización XML? ................................................................................................ 254
Atributos de costumbre formato SOAP ........................................................................................................ 257
Servicios Windows ................................................................................................................................... 260
Clase [Link] ......................................................................................................................... 260
Definición de los Servicios Windows ............................................................................................................. 260
ServiceController y ServiceBase .................................................................................................................... 260
Enumeraciones.............................................................................................................................................. 260
Instrumentación....................................................................................................................................... 268
Arquitectura .................................................................................................................................................. 268
Información general sobre WMI .NET ........................................................................................................... 268

Capítulo 9: Trabajando con Email y Clientes Inteligentes

Cómo Enviar Mensaje .............................................................................................................................. 275
Creando un mensaje de eMail ...................................................................................................................... 279
Enviando Email.............................................................................................................................................. 279
Clientes Inteligentes................................................................................................................................. 280
 Clientes Ligeros (Aplicaciones Windows) ............................................................................................ 280
Aplicaciones Web ................................................................................................................................ 280
Características de un cliente Inteligente ............................................................................................. 281
Manejo de datos ................................................................................................................................. 284
Manipulación de datos Integrada ....................................................................................................... 284
ClickOnce Deployment ........................................................................................................................ 288
Archivo de Aplicacion .......................................................................................................................... 290

Capítulo 10: Aprendiendo todo sobre [Link] 4.0

Arquitectura ............................................................................................................................................. 299
Data provider ...................................................................................................................................... 299
DataSets ............................................................................................................................................. 299
Entity Framework ............................................................................................................................... 300
El proveedor de datos .NET Framework .............................................................................................. 301
Objetos provistos por distintos proveedores de datos .NET ................................................................ 302
Estudiando el Objeto XXXDataAdapter ............................................................................................... 309
El Objeto DataSet ............................................................................................................................... 312
Modelo del Objeto DataSet ................................................................................................................. 312
Objeto SqlCommandBuilder ................................................................................................................ 313
Método Forma No Administrada ........................................................................................................ 314
Método Forma Administrada .............................................................................................................. 315
Creación de Tabla ............................................................................................................................... 328
Cargar los datos .................................................................................................................................. 330
Empezar a buscar los datos según lo escrito ....................................................................................... 330
Buscar en el campo Apellidos con las letras en cualquier posición ..................................................... 331
Creación de Módulos de ejecución de comandos ............................................................................... 335
Mantenimiento de Base de Datos con ADO 4.0 .................................................................................. 336

Capítulo 11: Crystal Report con [Link] 4.0

Utilizando Cristal Report ............................................................................................................................... 349
Tipo de Creación: ................................................................................................................................ 351
Usar Asistente de Informes: ............................................................................................................... 351
Como Informe en Blanco: ................................................................................................................... 351
A partir de un informe existente: ........................................................................................................ 352
Tablas Cruzadas: ................................................................................................................................ 352
Etiquetas: ........................................................................................................................................... 352
Datos del Proyecto: ............................................................................................................................ 352
Mostrando el Reporte ......................................................................................................................... 356
Esquema de Trabajo: .......................................................................................................................... 357
Manejo de Crystal Report ............................................................................................................................. 357
Reporte desde una tabla ..................................................................................................................... 359
Reporte de procedures y parametros ............................................................................................................ 364
Creación del Procedimiento Almacenado ........................................................................................... 364
Reporte de procedures y parametros ............................................................................................................ 369
Como trabajar [Link] 4.0 con XML ...................................................................................................... 374
Empezando con XML. .......................................................................................................................... 374
 Recordando Cómo se Maneja XML con DataSet. ................................................................................ 375
Objetos para Trabajar con XML .......................................................................................................... 375
Trabajando con xml – Ejemplo Inicial.................................................................................................. 376
Validando un XML – Transportando datos .......................................................................................... 378

Capítulo 12: Aplicación desarrolladas con Visual Studio 2010 y [Link] 4.0
Ejemplo de Mantenimiento utilizando los Objetos SqlCommand y SqlDataReader ...................................... 383
Mantenimiento de empleados ...................................................................................................................... 387
Ejemplo – Consulta por el Apellidos ............................................................................................................. 395
Ejemplo – Consulta por Categoría ................................................................................................................ 397
Ejemplo – Consultas por rango de Fechas..................................................................................................... 398
Ejemplo – Consulta Pedidos por Mes ............................................................................................................ 399
Ejemplo – Consulta Múltiple ........................................................................................................................ 401
Procedimientos Almacenados ....................................................................................................................... 401
Ejemplo – Consulta Múltiple ........................................................................................................................ 404

Capítulo 13: Aprendiendo [Link] en 2010

Introducción de [Link] .............................................................................................................................. 409
Que es un Servidor WEB................................................................................................................................ 411
Los Web Forms ............................................................................................................................................. 412
Programando con [Link] ........................................................................................................................... 417
Controles Web Básicos .................................................................................................................................. 421
Controles Web Avanzados ............................................................................................................................. 424
Creación de los Estilos Utilizando Hojas de Estilos ........................................................................................ 434
Controles de Validación................................................................................................................................. 435

Direcciones de Internet ......................................................................................................................... 437

 CAPÍTULO

1
Net Framework 4.0
 CAPÍTULO

1 Net Framework 4.0

El “Framework” o marco de trabajo, constituye la base de la plataforma .NET y denota la infraestructura

sobre la cual se reúnen un conjunto de lenguajes, herramientas y servicios que simplifican el desarrollo
de aplicaciones en entorno de ejecución distribuido.

Que es Net Framework

Cuando nosotros vemos las distintas formas que han ido cambiando nuestra vida a lo largo de los
años, nos damos con la sorpresa de que la tecnología ha ido cambiando de una manera mucho mas
rápida, esto ha producido una revolución en la tecnología empleada en el desarrollo de aplicaciones. El
primer gran cambio, fue el paso de la programación Estructurada (en modo DOS) a una programación
Orientada Objetos (API –Win 16) , más adelante con la evolución de los sistemas y la alta competitividad
del mercado se produce otro cambio con aplicaciones Win32 (componentes), y ahora estamos viviendo
otra evolución, lo que Microsoft llama .NET Framework o más comúnmente .NET.

Microsoft lanza esta nueva tecnología como respuesta a tecnología Java de Sun. El Framework .NET
tiene grandes similitudes con la plataforma Java.

Centrándonos en el concepto Framework .NET, como el término en inglés dice (Framework = Armazón)
es un marco en donde nuestras aplicaciones correrán.

El Microsoft .NET Framework, es un componente que provee soluciones pre-codificadas para

requerimientos comunes de los programas. Las soluciones pre-codificadas que forman la biblioteca
.NET, cubren un gran rango de necesidades de la programación de programas. Los programadores
las emplean y combinan con sus propios códigos en sus programas. El framework incluye soluciones
en áreas como: la interfaz de usuario, acceso a datos, conectividad a bases de datos, criptografía,
desarrollo de aplicaciones web, algoritmos numéricos y comunicación de redes.

Novedades del Framework 4.0

Este nuevo framework 4.0 de Visual Studio .NET trae muchas e interesantes nuevas características.
No solo vamos a tener un nuevo IDE (Visual Studio 2010), sino que vamos a disfrutar de nuevas
Herramientas y mejoras en las diferentes ambientes de desarrollo.

Ahora vamos a identificar alguna de estas novedades y mejoras, la vamos a resumirla y a conocerla de
poco a poco, a continuación detallamos algunas:

Security (Seguridad) - Se han hecho muchos esfuerzos para mejorar la seguridad en .NET, incluyendo
simplificación y transparencia en las implementaciones.

Common Language Runtime (CLR) - Se han implementado mejoras en Security, Parallel Computing,
rendimiento y diagnóstico, el nuevo DLR (Dynamic Language Runtime) y otros.
18 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Parallel Computing - El nuevo framework incluye un nuevo modelo de programación Paralela (multi-
hilos). La idea de este nuevo modelo es simplificar el desarrollo de multithread permitiendo a los
desarrolladores escribir código muti-hilos en lenguaje natural. Con todo esto, también se ha agregado
a LINQ este modelo de programación.

Dynamic Language Runtime - Incluido en el CRL se encuentra un nuevo Runtime para ejecución de
código dinámico (Dynamic Language Runtime). Al igual que Parallel Computing, la idea del DLR es
simplificar y facilitar el desarrollo de código dinámico en .NET. Este DLR es el encargado de ejecutar
código C# o VB en tiempo de ejecución como si se tratara de IronPhyton o IronRuby (que también se
ejecutan en el nuevo DLR).

Web - Las nuevas características del framework para aplicaciones web incluyen mejoras en [Link],
Dynamic Data, Web Forms, etc.

[Link] Web Forms - Algunas de las mejoras que se incluyen son:

• Posibilidad de establecer en meta tags.
• Mejoras en el control del View State.
• Mejoras en la generación de ID’s de los controles [Link].
• Mejoras en el renderizado de los controles FormView y ListView.
• [Link] Chart Control

Client - Se han implementado nuevas características en Windows Presentation Foundation (WPF) y

una nueva librería llamada Managed Extensibility Framework (MEF)

Managed Extensibility Framework - Esta nueva librería nos permite construir aplicaciones extensibles.
MEF nos permite definir puntos donde nuestra aplicación puede ser extensible y el descubrimiento de
esta extensibilidad utilizando metadatos sin la necesidad de cargar ensamblados para esas partes.

Data - Tenemos nuevas versiones de Entity Framework y Data Services.

Entity Framework - Las nuevas características son:

• Definición de Foreign Keys en el Modelo Conceptual.
• Nuevos métodos para el desarrollo de aplicaciones N-Tier, mejoras en la serialización a través de
WCF y en el Attach y Deatach de los objetos.
• Soporte para trabajar con nuestras propias clases de objetos (Persistence-Ignorant Object).
• Soporte para desarrollar utilizando el método Model-First. Esto nos permite desarrollar nuestro
modelo y obtener un script para generar nuestra base de datos.
• Nuevos tipos complejos.

Communications y Workflows - Nueva versión con nuevas características de Windows Communication

Foundation (WCF) y nueva y bastante mejorada versión de Windows Workflow Foundation (WF).

Diseñador WPF - El diseñador WPF se ha actualizado para incluir características como Data Binding
para el desarrollo de Windows Forms.
 Capítulo 1: Net Framework 4.0 19

Composición del Framework

La mejor forma de comprender como funciona el framework es ver gráficamente la estructura de las
capas, de la que estas compuestas:

Microsoft. NET Framework 4.0 proporciona las siguientes nuevas características y mejoras:

*. NET Framework 4.0 funciona al lado de los Framework versión 3.5 SP1. Las aplicaciones que se basan
en las versiones anteriores del Marco seguirán en esa versión. Sólo un subconjunto de la funcionalidad
es compartida por todas las versiones del Marco.

* Innovaciones en el Visual Basic y C # lenguas, por ejemplo declaración lambdas, implícita

continuaciones línea, dinámica de expedición, nombre y / parámetros opcionales.

* El Framework en las librerías de [Link], lo que simplifica la manera en contra de los desarrolladores
de programa de bases de datos relacionales por elevar el nivel de abstracción, tiene muchas
características nuevas. Estos incluyen la ignorancia y la persistencia POCO apoyo, perezoso carga,
prueba de desarrollo impulsado por el apoyo, las funciones en el modelo, y los nuevos operadores de
LINQ.

* Mejoras en WPF:
Se ha añadido soporte en Windows Presentation Foundation (WPF) para Windows 7 Multi-Touch, la
cinta de control, y las características de extensibilidad de la barra de tareas.

Se ha añadido soporte de WPF en la superficie de 2.0 SDK.

Nueva línea de negocio incluyendo los controles gráficos de control, edición inteligente, tabla de datos,
y otros que mejoran la experiencia para que los desarrolladores construir aplicaciones centradas en
datos.

Mejoras en el rendimiento y la escalabilidad, visual o las mejoras en la claridad de texto, diseño de píxel
romperse, localización, y la interoperabilidad.
20 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

* Mejoras en Windows Workflow (WF):

Que permiten a los desarrolladores una mejor acogida e interactuar con flujos de trabajo. Estas
actividades incluyen un modelo de programación mejorado, una mejor experiencia de diseño, un nuevo
diagrama de flujo de modelado estilo, una paleta de mayor actividad, el flujo de trabajo, normas de
integración, y nuevas funciones de correlación mensaje. . NET Framework también ofrece importantes
ganancias de rendimiento para flujos de trabajo basados en WF.

* Mejoras a Windows Communication Foundation (WCF):

Como apoyo para el Fondo de Operaciones de Servicios de flujo de trabajo que permitan el flujo
de trabajo con programas de actividades de mensajería, la correlación de apoyo y duradera de dos
vías de comunicación y las capacidades de acogida ricos. Además, .NET Framework 4 proporciona
nuevas características tales como el Fondo de Operaciones de descubrimiento de servicios, el router
de servicios, la simplificación de la configuración y una serie de mejoras a la cola, RESTO apoyo,
diagnóstico, y el rendimiento.

* Innovadoras nuevas características de programación paralela, como circuito paralelo de apoyo, tarea
paralela Library (TPL), LINQ Paralelo (PLINQ), la coordinación y estructuras de datos que permiten los
desarrolladores aprovechar la potencia de los procesadores multi-núcleo.

COMPONENTES DEL FRAMEWORK 4.0

1. Runtime del lenguaje común
Esta capa es la que se encarga de manegar los servicios básicos del framework, tales como la
administración de memoria, la recolección de los elementos no utilizados, el control estructurado de
excepciones y del sub procesamiento múltiple. El CLR tiene estas características:
• Compilación Just=In=Time JIT
• Gestión Automática de Memoria: carga en memoria, liberación de memoria.
• Gestión de Errores Consistentes
• Gestiona la seguridad del código ejecutado
• Abre posibilidades a otros fabricantes para incorporar sus lenguajes
• Ejecución Basada en Componentes Assemblies
• MultithReading
 Capítulo 1: Net Framework 4.0 21

2. Biblioteca de clases
De muy poco serviría a los desarrolladores el contar con una plataforma de ejecución de aplicaciones
tan sofisticada y robusta como el CLR sin tener además un conjunto de funcionalidades y componentes
empaquetados listos para aprovechar y reutilizar en sus aplicaciones. Justamente ese es el propósito
Biblioteca de Clases, que provee cientos de tipos básicos (clases e interfaces principalmente) orientados
a objetos, extensibles mediante herencia, independientes del lenguaje de programación de alto nivel
que se desee utilizar y organizados en namespaces jerárquicos.

Estas bibliotecas la podemos en los siguientes grupos:

La biblioteca de clases base (BCL) = define todos los tipos de datos básicos, tales como [Link]
(raíz de la jerarquía de objetos .NET), tipos numéricos y de fechas, tipo string, matrices y colecciones.
La BCL contiene también clases que administrarán las características centrales de .NET: entrada/salida
de archivos, subprocesamiento, serialización y seguridad.

Capa de dato = La capa de datos y XML contienen las clases que trabajan con bases de datos y con XML.
Anteriormente el soporte XML era una compatibilidad proporcionada por un componente externo.
Podemos decir que XML es el formato que utiliza para almacenar cualquier tipo de información. La
parte de datos es la que se conoce como [Link].

Capa de formularios y ASP = Las dos capas siguientes son [Link] y Windows Forms Capas de Diseño
Aquí se sitúan todas las clases que podemos utilizar para generar las páginas web en el primer caso y
las ventanas estándares o formularios en las aplicaciones de Windows en el segundo caso.

Aunque estén en el mismo nivel las tecnologías son muy distintas. Web Forms se ejecuta en el servidor
y produce codigo HTML y es la base de las conocidas aplicaciones Web. Windows Forms se ejecuta en
el cliente, con las características de un equipo Windows.
22 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

La biblioteca de clases de Framework está formada por una colección de ensamblados (o

Assembly), cada uno de los cuales comprende una o más DLL. Un ensamblado consiste en un
conjunto de tipos y recursos reunidos para formar la unidad mas elemental de código que puede
ejecutar el entorno NET. Estos ensamblados son los elementos con los que construiremos una
aplicación.

3. CLS y lenguajes
Uno de los objetivos de diseño de la plataforma .NET fue el ser independiente al lenguaje de
programación elegido para el desarrollo de aplicaciones. Para lograr esto es que se creó la Especificación
de Lenguaje Común (o CLS, por sus siglas en inglés), que define y estandariza un subconjunto de todas
las características soportadas por el CLR y que son necesarias en la mayoría de las aplicaciones. Todos
los componentes desarrollados y compilados de acuerdo con la especificación CLS pueden interactuar
entre si, independientemente del lenguaje de programación de alto nivel en el que fueron escritos.
 Capítulo 1: Net Framework 4.0 23

El framework nos provee la implementación de 4 lenguajes compatibles con CLS, junto con sus
compiladores:
• Microsoft Visual Basic .NET
• Microsoft Visual C# .NET
• Microsoft Visual F#.NET
• Microsoft Visual C++.NET

Si les quedo alguna duda en la definición, esto quiere decir que una aplicación escrita en
cualquier lenguaje, por ejemplo, en Visual [Link], puede incorporar sin problemas nuevas
partes escritas en lenguajes tales como C# o C++ .
Un punto importante a destacar es que la elección del lenguaje de alto nivel en el que debe
escribirse una aplicación .NET prácticamente ha sido reducida a una cuestión de gustos
personales y comodidad con la sintaxis. Todos utilizan el mismo runtime, todos utilizan el mismo
conjunto de bibliotecas de la misma forma, no existen diferencias notorias de performance entre
ellos.

Arquitectura de .NET Framework 4.0

24 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

La versión 3.5 de .NET Framework se basa en las versiones 2.0 y 3.0 de .NET Framework, incluidos los
Service Pack de estas versiones. Ahora entendamos un poco la relación que existe entre las versiones
2.0 hasta la actual 4.0:

Relación entre las versiones 2.0, 3.0, 3.5 y 4.0 del Framework
Los componentes que se enumeran a continuación se consideran parte de .NET Framework 3.5:
• .NET Framework 2.0
• Service Pack 1 de .NET Framework 2.0, que actualiza los ensamblados incluidos en .NET Framework
2.0.
• .NET Framework 3.0, que utiliza los ensamblados de .NET Framework 2.0 o .NET Framework 2.0
SP1 (si está instalado), e incluye los ensamblados necesarios para las tecnologías introducidas en
.NET Framework 3.0. Por ejemplo, [Link] y [Link], que son
necesarios para Windows Presentation Foundation (WPF), se instalan con .NET Framework 3.0.
• .Service Pack 1 de NET Framework 3.0, que actualiza los ensamblados introducidos en .NET
Framework 3.0.
• Nuevos ensamblados que proporcionan una funcionalidad adicional a .NET Framework 2.0 y 3.0 y
las tecnologías nuevas de .NET Framework 3.5.

Si alguno de estos componentes no se encuentra en el equipo al instalar .NET Framework 4.0, se

instalará automáticamente

La relación entre las versiones 2.0, 3.0 y 3.5 de .NET Framework es diferente a la relación que
existe entre las versiones 1.0, 1.1 y 2.0. de .NET Framework, que son totalmente independientes
unas de otras, Cuando las versiones 1.0, 1.1 y 2.0 están en el mismo equipo, cada versión tiene su
propio Common Language Runtime, sus propias bibliotecas de clases, su propio compilador, etc.

Rápidamente hagamos en un resumen de las características de las distintas versiones comentadas

anteriormente:

A. NET Framework 2.0

Las tecnologías siguientes se incluyen en .NET Framework 2.0.
• Common Language Runtime (CLR).
• Compatibilidad con los tipos y métodos genéricos.
• Compiladores para C#, Visual Basic, C++ y J#.
• Bibliotecas de clases base.
• [Link].
• [Link].
• Formularios Windows Forms.
• Servicios web.

B. NET Framework 2.0 SP 1

El Service Pack 1 de .NET Framework 2.0 actualiza el CLR y varios de los ensamblados que se incluyen
en .NET Framework 2.0, y se puede instalar con independencia de .NET Framework 3.5. La mayoría de
las actualizaciones de .NET Framework 2.0 no constituyen cambios importantes, aunque hay algunos
casos en que se agregan nuevos elementos de API o se modifica el comportamiento.
 Capítulo 1: Net Framework 4.0 25

C. NET Framework 3,0

NET Framework 3.0 necesita que .NET Framework 2.0 esté instalado en el equipo. Si un usuario instala
.NET Framework 3.0 en un equipo que no tiene .NET Framework 2.0, se instalará automáticamente.

Las tecnologías siguientes se introducen en .NET Framework 3.0:

• Windows Presentation Foundation (WPF).
• Windows Communications Foundation (WCF).
• Windows Workflow Foundation (WF).

D. NET Framework 3.0 SP 1

El Service Pack 1 de .NET Framework 3.0 actualiza varios ensamblados incluidos en .NET Framework
3.0 y se puede instalar con independencia de .NET Framework 3.5. Estas actualizaciones incorporan
cambios intrascendentes, nuevos elementos de API y funciones adicionales a las tecnologías de .NET
Framework 3.0. Cuando se instala .NET Framework 3.0 SP1, se instala .NET Framework 2.0 SP1 si aún
no se encuentra en el equipo.

E. NET Framework 3.5

.NET Framework 3.5 introduce nuevas características para las tecnologías de las versiones 2.0 y 3.0
e incorpora tecnologías adicionales en forma de nuevos ensamblados. Las tecnologías siguientes se
introducen en .NET Framework 3.5:
• LINQ.
• Nuevos compiladores para C#, Visual Basic y C++.
• [Link] AJAX.
• Tipos adicionales de la biblioteca de clases base.

F. NET Framework 4.0

En .NET Framework 4, ha habido importantes mejoras dentro de los espacios de nombres de Windows
Communication Foundation (WCF) 4 y Windows Workflow Foundation (WF). Los desarrolladores de
NET pueden utilizar estas tecnologías, de manera independiente o en conjunto, para no tener que
sacrificar la facilidad de creación de servicios por servicios escalables y de rendimiento. El .NET
Framework 4 trabaja codo a codo con el Framework versión 3.5 Service Pack 1. Las aplicaciones que
se basan en versiones anteriores del Framework se continuarán ejecutando en esta versión. El ADO.
NET Entity Framework, lo que simplifica cómo el programa de desarrolladores de bases de datos
relacionales contra elevando el nivel de abstracción, tiene muchas características nuevas. Estos incluyen
la ignorancia perseverancia y apoyo POCO, carga lenta, apoyar el desarrollo basado en pruebas, las
funciones en el modelo, y los nuevos operadores de LINQ.
26 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

VERSIONES DE VISUAL STUDIO 2010

Conociendo Algunas Nuevas Tecnologías del Net Framework 4.0

Windows Presentation Foundation

Es un subsistema de Windows (librerías integradas en el sistema operativo), orientado a unificar los
mecanismos de creación y gestión de interfaces de usuario. WPF se incluye en la versión 3.0 del .NET
Framework y permite desarrollar aplicaciones ricas en interfaz de usuario, animaciones, etc. También
esta disponible para Windows Vista, Windows XP y Windows Server 2003.

Es una forma productiva para aprovechar la interfaz de usuario utilizando medios y documentos para
entregar una experiencia al usuario sin precedentes.
 Capítulo 1: Net Framework 4.0 27

¿El por qué de WPF?

Como ya se ha anticipado en su definición, WPF nace con el propósito de unificar, y es que cuando
hablamos de interfaces de usuario nos vienen a la cabeza tres escenarios o entornos muy concretos:
• Aplicaciones de escritorio.
• Aplicaciones Web.
• Aplicaciones para dispositivos móviles.

La nueva filosofía que se nos plantea con herramientas como WPF radica en definir los elementos
esenciales que deben componer la interfaz de usuario, delegando a un segundo paso la definición del
aspecto de los mismos.

Pensemos en un ejemplo, queremos desarrollar una aplicación para el control de Ingresos y Egresos,
pensemos entonces que dicha aplicación la vamos a construir en Aplicación Windows, Web y una
Aplicación Móvil, encontramos que cada una de ellas tiene aspecto mejores o peores según sea el caso
sobre las otras, algo que es evidente es que el entorno Windows hasta la fecha es sin duda el que nos
permitirá crear interfaces más ricas y complejas para el usuario, pero la idea es que debemos tratar de
realizar interfaces usando las mismas herramientas independientemente del entorno o entornos donde
pretendamos ejecutar nuestra aplicación. En el ejemplo anterior, mientras que diseñaría un formulario
Windows con una tecnología muy concreta como puede ser WinForms para la aplicación de escritorio,
para ejecutar bajo el navegador Web, voy a tener que redefinir por completo la interfaz, usando otra
tecnología como puede ser [Link]. En resumen, doble trabajo, doble necesidad de conocimientos.

También incluye el Lenguaje de Marcado de Aplicaciones Extensibles (XAML), este lenguaje define
elementos XML para especificar exactamente la apariencia de las interfaces de usuario, disponen de
atributos, además de incorporarse fácilmente al desarrollo de WinForms.
28 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Windows Communication Foundation

Es un conjunto de tecnologías .Net para construir y conectar sistemas, diseñadas alrededor del manejo
de los servicios web. Permitiendo el desarrollo de servicios seguros, confiable y con soporte para
transacciones. Que no solo operan en plataformas Microsoft (en algunos casos se utlizan con otros
lenguajes Programación, tales el caso de PHP). WCF forma parte del framework .Net 3.0, el cual no
es más que un framework .Net 2.0 con muchas más librerías (adicionales). Así mismo WCF combina y
extiende las tecnologías actuales para construir sistemas distribuidos bajo plataformas Microsoft con
la intención de proveer un solo marco de trabajo unificado, haciendo uso de tecnologías como:
• [Link] Web Services (ASMX)
• .Net Remoting
• .Net Enterprise Services
• Web Services Enhancement (WSE)

Los objetivos primordiales de WCF son los siguientes:

• Soportar un gran conjunto de protocolos para servicios web dado que las tecnologías actuales para
web services proveen soporte para un tipo de interoperabilidad muy básica entre aplicaciones.
• Diseño orientado a servicios, el desarrollo orientado a servicios ha permitido hacer frente al reto
de construir software que se adapta con rapidez a las necesidades de negocio.
• Modelo de programación unificado permitiendo flexibilidad en cómo los datos se representa y se
transmiten (Esto se logra usando XML como el modelo de datos).

Algunas Definiciones necesarias

Cuando nosotros hablamos de un servicio WCF, entendemos que es un programa que es un programa
que expone una colección de ‘Endpoints’ (extremos o puntos de entrada). Cada ‘Endpoint’ es un punto
de entrada de comunicación con la red universal.

Un ‘Endpoint’ de un Servicio está compuesto por una ‘Address’ (Dirección), un ‘Binding’ (Enlace) y un
‘Contract’ (Contrato).
 Capítulo 1: Net Framework 4.0 29

La dirección (Address) de un ‘Endpoint’ es una dirección de red donde reside dicho ‘Endpoint’.

El Enalace (binding) de un ‘Endpoint’ especifica como se comunica dicho ‘Endpoint’ con el resto del
mundo, incluyendo aspectos como el protocolo de transporte, tipo de codificación , y requerimientos
de seguridad.

El contrato (Contract) de un endpoint especifica qué comunica dicho endpoint y básicamente está
compuesto por una colección de mensajes organizados internamente en operaciones que tienen un
patrón de intercambio de mensajes.

Windows Workflow Foundation

Es el modelo de programación de Microsoft que permite crear aplicaciones con funcionalidad de

workflow. Consiste en un motor de workflow embebido y en un módulo de ayuda para Visual Studio.

Que es WorkFlow?
El flujo de Trabajo (workflow en ingles) es el estudio de los aspectos operacionales de una actividad
de trabajo: como se estructuran las tareas, como se realizan, el cual es su orden correlativo, como se
sincronizan, como fluye la información.

Una aplicación de Workflow automatiza la secuencia de acciones, actividades o tareas utilizadas para
la ejecución del proceso.

Windows Workflow Foundation, ofrece el modelo de programación y el motor de tiempo de

ejecución para crear aplicaciones habilitadas para el flujo de trabajo en una plataforma Windows
equipada con .NET Framework 2.0 o posterior y, como mínimo, con Windows XP Service Pack 2 o
Windows Server® 2003.
30 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Uno de los mayores mitos de Windows Workflow Foundation es que todas las actividades constitutivas
están vinculadas de forma secuencial o mediante una transición de equipos de estado. De hecho,
Windows Workflow Foundation virtualiza el modelo de ejecución como autómata de actividades. Es
un conjunto de actividades que coordinan gente y programas. Con él, Microsoft está redefiniendo el
flujo de trabajo incorporándolo en una plataforma de desarrollo de flujo principal y ofreciendo soporte
para flujo de trabajo humano y de sistemas a todos sus clientes y tipos de servidor. Las funciones de
flujo de trabajo estarán disponibles para los desarrolladores a través de WinFX (TM), el nuevo modelo
de programación de Windows Vista (TM).

Windows Workflow Foundation soporta una amplia gama de situaciones de flujo de trabajo, incluyendo
aplicaciones de línea de negocio, flujo de páginas de interfaz de usuario, flujo de trabajo centrado
en documentos, flujo de trabajo humano, flujo de trabajo compuesto para aplicaciones orientadas
a servicios, flujo de trabajo impulsado por reglas empresariales y flujo de trabajo para gestión de
sistemas

Las aplicaciones pueden cargar el motor de flujo de trabajo y conectar una gran variedad de
componentes del servicio de tiempo de ejecución. Windows Workflow Foundation es muy extensible,
por lo que puede crear sus propios componentes personalizados para tratar preocupaciones
empresariales concretas.

Windows Workflow Foundation también ofrece compatibilidad con [Link] para facilitar la creación
y ejecución de flujos de trabajo que se ejecutan en el entorno de Internet Information Services (IIS)/
[Link].

LO NUEVO EN VISUAL STUDIO 2010

A continuación enumeramos las principales características en las que está centrado el desarrollo de
Visual Studio 2010:

Aplicaciones Departamentales (Departamental Applications): Básicamente este enfoque está en

aquellas aplicaciones que no necesariamente son aplicaciones gigantes o empresariales, es decir son
más aplicaciones pequeñas desarrolladas para un fin específico que generalmente soluciona algún
problema o conflicto dentro de un departamento de una empresa
 Capítulo 1: Net Framework 4.0 31

Office Business Applications: Esta versión permitirá trabajar con diferentes versiones de Ms Office (32
y 64bits) y entregarlas como un paquete simple de instalación. Se incluye soporte para la realización
de la Interfaz gráfica con WPF, entre otros.

Web & RIA: Hay un especial enfoque en proveerle a los web developers la capacidad de poder ser
más productivos al momento de desarrollar aplicaciones Web y RIA, esto incluye mejor soporte a
estándares, integración de nuevas frameworks como [Link] MVC, mejor experiencia con javascript
y jquery, entre otros.

Code Focused: Para muchos de los desarrolladores que nos facina estar dentro del IDE, escribiendo,
oliendo y hasta respirando código, en la nueva versión de VS, se tiene previsto proveernos de muchas
herramientas para aumentar nuestra productividad, entre las que podemos mencionar: herramientas
para mejorar la experiencia de implementar TDD, un nuevo editor de código re-escrito sobre WPF con
una mejor experiencia de usuario, entre otras.

Windows: Enfocada a explotar mucho de WPF, WCF y WWF.

Tendencias Emergentes (Emerging Trends): Aqui hay mucho, encontramos lenguajes dinámicos,
soporte para parallel programming, Dynamic Data, Astoria, etc.

Desarrollador Web
Herramientas para deployment integradas más flexibles: Lo resumimos a una característica llamada
“One click Deployment”

Más soporte para estándares web: Mejor control sobre el código para garantizar el uso de estándares.

Diferentes Frameworks: Seguiremos teniendo todo lo mejor de Webforms y nuevas funcionalidades,

pero un salgo muy grande es la inclusión de [Link] MVC.

Mejores herramientas y soporte para desarrollo de RIA’s

Line of Business (LOB) Desarrollador Windows

Exponer Data es más rápido y fácil que nunca: Esto lo podemos lograr via REST services con Data
Services, Dynamic Data over forms.

Soluciones más flexibles para deployment: Clilck Once! mejorado

Desarrollador Office
Capacidad de trabajar las últimas plataformas disponibles de office
Herramientas de Soporte para Sharepoint
Mejoras a los lenguajes para trabajar con la API de Office
Mejor soporte para Deployment

Independent Software Vendor (ISV)

Fácil Construcción de aplicaciones concurrentes (Parallel ProgrammingSoporte para hacer aplicaciones
extensibles (MEF)
Mejor Experiencia para Debugging
Nuevo modelo para el IntelliSense que escale a fuentes de código gigantes
32 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Otras características de Visual Studio 2010

Una características importante es que se agregaron apatir de Visual Studio 2008 es la capacidad de
especificar el Framework sobre el cuál se desea compilar. En las cajas de dialogo Advanced Compiler
Settings (VB) y Advanced Build Settings (C#), ahora existe un nuevo campo denominado Target
Framework que permite seleccionar lo siguiente:
.NET Framework 2.0
.NET Framework 3.0
.NET Framework 3.5
.NET Framework 4.0

Nosotros encontramos muchas novedades con C# 4.0 y VB 10.0 como por ejemplo delegados relajados,
propiedades automáticas, tipos anónimos, método de extensión y muchas otras cosas, …Amigos no
se preocupen muchos de estos temas lo vamos a tocar en el libro, pero lo que deben entender, es
que trabajar con diferente Net Framework (generación multiplataforma), podremos usar estas nuevas
características de nuestros lenguajes favoritos y generar para aplicaciones de .NET 4.0.

Soporte a Windows Presentation Foundation de manera nativa. Cuando se inicia un proyecto,

seleccionando el lenguaje, se pueden crear cuatro (4) tipos de proyecto WPF:
WinFX Windows Application
WinFX Web Browser Application
WinFX Custom Library
WinFX Service Library

Existe un framework sobre ADO para proveer a los desarrolladores un modelo de abstracción para
programar en alto nivel (clases y objetos) y manipular información relacional (BD). Esta característica de
abstracción se brinda gracias a la tecnología LINQ, Language INtegrated Query es un nuevo método de
acceso a datos totalmente integrado en nuestro lenguaje habitual y de una forma muy independiente
de la fuente de donde provengan (colecciones, XML, motores de bases de datos, etc.). La cuál es una
tecnología que permite hacer consultas contra la información que se maneja en las entidades, sin
utilizar T-SQL..

La tendencia al desarrollo constante de creación de aplicativos WEB, hacen que Microsoft ya incluiya
[Link] AJAX, así como 3 nuevos controles que son ListView, DataPager y LinqDataSource. Además, el
IDE ha sido muy mejorado e incluye soporte para intellisense y depuración de Javascripts.
 Capítulo 1: Net Framework 4.0 33

Incluye nuevas plantillas de proyectos, así como un diseñador para WPF integrado con soporte para
la comunicación WPF-WinForms. También se ha añadido el soporte para Firefox de la tecnología
ClickOnce.

Para aquellas personas que por necesidad o por hobbie desean trabajar o interactuar con office se
ofrece soporte total para las personalizaciones (customisations) de Office 2007, así como para las
plantillas de Office 2003.

Para el desarrollo en dispositivos móviles, hay decenas de nuevas características, como el soporte para
las versiones compactas de LINQ y WPF, o, a nivel de IDE, Unit Testing for Devices.
 CAPÍTULO

2
Aprendiendo a conocer
Visual Studio 2010
 CAPÍTULO

Aprendiendo a conocer
2 Visual Studio 2010
Algunos Conceptos:
Estos conceptos son necesarios conocer para tener la base conceptual de los temas que vamos a tratar:

FUNDAMENTOS DE PROGRAMACIÓN
CONCEPTOS BÁSICOS
Clases / Objetos
Prácticamente todo lo que manejemos en el entorno .NET es una clase u objeto, de hecho todas las
clases derivan de una clase u objeto básico: la clase [Link]

Programación Orientada a Objetos (OOP / PPO)

Una forma de programar basada en la reutilización de código mediante herencia, encapsulación y
polimorfismo.

Herencia
La posibilidad de que una clase herede las propiedades y métodos de otra clase de forma que se
puedan usar con la nueva clase de igual forma que si se hubiesen escrito directamente en ella.

Encapsulación
La posibilidad de ocultar el código usado para implementar un método o cualquier otro procedimiento
o función de forma que lo único que interese sea el interface expuesto por la clase u objeto.

Polimorfismo
La posibilidad de usar en clases diferentes propiedades o métodos con el mismo nombre de forma que
cuando se usen no nos preocupe a que clase pertenece.

Por ejemplo el objeto básico del que derivan todas las clases de .NET tiene una propiedad llamada
ToString, ésta propiedad estará implementada de forma diferente en diferentes clases, pero nosotros
la usaremos de la misma forma, sin importarnos que objeto estemos usando.

Interface
Se dice que las propiedades y métodos expuestos por una clase forman el interface de la misma.

Clases abstractas
Son clases que exponen un interface el cual hay que usar en las clases que se hereden de dicha clase
abstracta.
38 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Interface / Implements
Los interfaces a diferencia de las clases es que no hay que escribir código para los métodos o
propiedades que expone, simplemente se indica la “declaración”.

Usando Implements, se pueden usar esas interfaces en las clases, aunque hay que escribir el código de
cada método o propiedad implementado.

Procedimiento
Un método, función o propiedad de una clase o módulo.

Método
Un procedimiento (Sub, Function -función) que se usa para realizar una tarea específica en la clase o
módulo.

Sub
Un procedimiento SUB es como una instrucción, es decir, realiza una tarea (ejecuta el código que haya
en su interior), pero no devuelve un resultado.

Function (Función)
Los procedimientos FUNCTION son como las funciones del [Link], es decir, realizan una tarea, al igual
que un Sub, pero siempre suelen devolver un valor, resultado del código que se ha ejecutado en su
interior. A las funciones no se les puede asignar valores, a diferencia de las Propiedades.

Property (Propiedad)
A diferencia de los métodos, las propiedades se usan para “configurar” la forma que tendrá la clase.
Algunas veces es difícil diferenciar un método de una propiedad, pero por convención los métodos
realizan tareas.

Por ejemplo, el ancho de un objeto es una propiedad, mientras que mostrar el objeto se realizaría con
un método. A las Propiedades se les puede asignar valores y pueden devolverlos, (como las funciones).
Aunque también pueden existir propiedades de solo lectura, (solamente devuelven valores), o de solo
escritura, (sólo se les puede asignar valores, pero no los devuelven).

Parámetro
Los métodos o propiedades pueden tener parámetros, (uno o varios), los cuales le indicarán los valores
que deben usar para la tarea que debe realizar. Por ejemplo, un método Contar podría recibir un
parámetro con el valor de las veces que tiene que contar.

Parámetros opcionales
Algunos procedimientos que aceptan parámetros, pueden tener también parámetros opcionales,
los cuales, como su nombre indica, pueden o no ser incluidos en la llamada al procedimiento.
Los parámetros opcionales tienen unos valores por defecto, el cual se usará en caso de que no se
especifique.

Variable
Son “espacios” de memoria en la que se almacena un valor. Se usarán para guardar en memoria los
valores numéricos o de cadena de caracteres que nuestro programa necesite.
 Capítulo 2: Aprendiendo a conocer Visual Studio 2010 39

Constante
Valores numéricos o de cadena que permanecen constantes, sin posibilidad de cambiar el valor que
tienen. En caso de que necesitemos cambiar el valor, usaremos las variables.

Evento
Los eventos son procedimientos (SUB) que se ejecutan normalmente cuando el sistema Windows
los provoca, por ejemplo, al hacer clic en una ventana o en cualquier objeto de la ventana, cuando
cambiamos el tamaño de una ventana, cuando escribimos en una caja de textos, etc.

Handles
En [Link] se usa Handles, seguido del nombre del evento, para indicar qué evento es el que se maneja
en el procedimiento indicado.

El formato suele ser: Sub Nombre(parámetros) Handles [Link]

Sobrecarga (Overload)
Se dice que un método está sobrecargado cuando existen distintas versiones de dicho método en la
clase. Por ejemplo métodos con el mismo nombre que reciban parámetros de distintos tipos.

Formulario (ventana)
Un formulario es una ventana de Windows la cual usaremos para interactuar con el usuario, ya que en
dicha ventana o formulario, estarán los controles y demás objetos gráficos que mostraremos al usuario
de nuestra aplicación.

Los formularios también son llamados “formas” o Forms en su nombre en inglés.

MyBase
La palabra clave MyBase se comporta como la clase de la que ha derivado la clase actual, es decir si
una clase deriva de una (o hereda a otra) clase, MyBase se referirá a dicha clase base, de esta forma
es posible acceder a los métodos, propiedades y eventos de la clase de la que se deriva (o hereda) la
clase actual.

Me (this)
La palabra clave (o instrucción) Me hace referencia a la clase actual. Por ejemplo [Link] se refiere
a la propiedad Width de la clase actual. En C# en lugar de Me es this.

Colecciones
Serie de datos que están guardados en una lista, array (o matriz) o una colección propiamente dicha y
que permite interactuar con los elementos de las mismas, pudiendo añadir, recuperar, eliminar uno o
todos, saber cuántos elementos hay, etc.

Expresiones
Una expresión es una secuencia de operadores y operando que describe un cálculo. Normalmente
una expresión se evalúa en tiempo de ejecución. Existen expresiones numéricas y alfanuméricas o de
caracteres.
40 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Expresiones Lógicas
Las expresiones lógicas son expresiones pero cuyo resultado es un valor “lógico” (verdadero o falso).
Este tipo de expresiones se usan normalmente con instrucciones que normalmente necesitan un valor
verdadero (true) o falso (false).

Módulo
Los módulos, al igual que las clases, son “espacios” en los cuales se incluyen declaraciones de variables,
procedimientos, funciones, etc.

Pero a diferencia de las clases, el código contenido en un módulo siempre está disponible de forma
directa, sin necesidad de crear una “instancia” de dicho módulo.

Instancia
Para poder usar una clase u objeto, hay que crear una instancia del mismo. Es decir, debemos declarar
una variable y a esa variable asignarle el objeto o clase en cuestión para que podamos usarlo. Es como
si tuviésemos que darle vida al objeto para poder usarlo.

Enumeraciones (Enum)
Las enumeraciones son una serie de valores constantes (de tipo numérico), que de alguna forma
están relacionadas entre sí. A diferencia de las constantes normales, una variable declarada como una
enumeración, puede tomar cualquiera de los valores indicados en la enumeración.

Array (matrices)
Los arrays (o matrices) son un tipo de variable que permiten tener más de un elemento, (o valor en su
interior), a los que se pueden acceder mediante un índice.

Un array también es el tipo en el que se basan todas las matrices o arrays.

Common Language Runtime (CLR)

El CLR (Common Language Runtime) es el motor en tiempo de ejecución del .NET Framework, es decir
la parte del “entorno” que se encarga de ejecutar el código de los lenguajes del .NET Framework.

SOLUCIONES, APLICACIONES Y PROYECTOS

TÉRMINOS Y DEFINICIONES
Una solución es un recipiente para proyectos y elementos de solución que pueden incluirse en una
aplicación. Normalmente, una solución contiene uno o más proyectos relacionados.

Un proyecto es un recipiente dentro de una solución que se utiliza para administrar, generar y depurar
lógicamente los elementos de proyecto que constituyen nuestra aplicación.

ARCHIVOS DE PROYECTOS Y SOLUCIONES

Visual Studio .NET soporta numerosos tipos de archivos y sus extensiones de archivo asociadas. La
siguiente tabla describe algunos tipos de archivos habituales específicos para las soluciones basadas
en Visual Basic .NET.
 Capítulo 2: Aprendiendo a conocer Visual Studio 2010 41

Extensión Nombre Descripción

.sln Solución Visual Studio Organiza proyectos, elementos de proyectos
y elementos de soluciones en una solución
proporcionando al entorno referencias a sus
ubicaciones en disco.
.suo Solution user options Registra todas las opciones que podemos asociar
a nuestra solución de forma que cada vez que
abramos la solución incluya las personalizaciones
que hayamos realizado.
.vb Proyecto Visual Basic Representa los archivos de formularios, controles
de usuario, clases y módulos que pertenecen a la
solución de un solo proyecto. Los archivos que no
estén basados en un lenguaje de programación
tienen su propia extensión. Por ejemplo, un archivo
Crystal Report tiene la extensión .rpt, y un archivo
de texto tiene la extensión .txt.
.vbproj Proyectos Visual Basic Representa los archivos de formularios, controles
de usuario, clases y módulos que pertenecen a la
solución con múltiples proyectos. Esta extensión
nos permite diferenciar entre archivos escritos en
Visual Basic .NET y otros lenguajes compatibles con
.NET. (Visual C# utiliza .csproj.)
.aspx .asmx Elementos de Los elementos de proyecto Web incluyen archivos
.asax proyecto Web Web específicos como .aspx para Web Forms,
.asmx para servicios Web XML, y .asax para clases
globales de aplicaciones. Los proyectos Web
también utilizan la extensión .vb para clases y
módulos.

APLICACIONES DE CONSOLA
Bueno ahora si, después de haber entendido un poco la plataforma en la cual se basa el desarrollo en
Net, hablamos del Net Framework, ahora pasamos a desarrollar pequeñas aplicaciones como parte
inicial el aprendizaje de Visual Studio 2010.

Cuando empezamos por primera vez a trabajar con Visual Studio(después de una instalación), nos
muestra una ventana en la cual nosotros podemos elegir cual es el lenguaje de programación que va
ser por defecto (eso no significa que no podamos utilizar los otros lenguajes del visual studio)

Vamos empezar a crear nuestro primer proyecto, si nos damos cuentas de las versiones anteriores
todavía están las mayoría de proyectos que antes creábamos. Además ahora encontramos aplicaciones
WPF Browser Application, WPF Custom Control Library, WPF User Control Library y otros.

Empecemos desarrollando Proyectos de Aplicación de Consola, que utiliza un formato de salida y

entrada de datos en modo texto. Seleccione Console Applicatio, escribamos los siguientes Datos
42 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Lo más común dentro del desarrollo bajo la plataforma .Net es la creación de aplicaciones Web
o aplicaciones Windows sin embargo la mejor forma de sentar unas bases firmes acerca de la
programación orientada a objetos es comenzar construyendo aplicaciones sencillas de consola.

La clase Console, permite mostrar información en la pantalla así como capturar la información
que introduzca el usuario, cabe destacar que los métodos de la clase Console son de tipo Shared,
esto significa que no es necesario crear un objeto a partir de la clase para invocar a sus métodos,
es posible hacerlo indicando el nombre de la clase seguido de un punto y el nombre del método.

El método WriteLine() y Write()

Este método es el que se usa para mostrar texto en la consola, el método escribe en la pantalla el valor
que le pasemos como parámetro.

El parámetro que recibe el método puede ser de varios tipos, ya sea una cadena de caracteres, un
número entero, una línea en blanco, etc..., la diferencia que existe entre estos 2 metodos es que el
WriteLine, escribe y deja el cursor en la siguiente linea

El método ReadLine() y Read()

Este método se usa para recoger la información que el usuario introduce cuando la aplicación así lo
requiera. Cuando invocamos al método [Link]() el sistema queda en espera hasta que el
usuario pulsa la tecla Intro.

Si se asigna la llamada a [Link]() a una variable se consigue capturar el dato introducido por
el usuario, para después poder operar con él, el Metodo Read() se diferencia del anterior porque no
espera que el usuario pulse intro para capturar el dato introducido, sino que lo hace tras la pulsación
de cualquier tecla, capturando el valor ASCII
 Capítulo 2: Aprendiendo a conocer Visual Studio 2010 43

Ejemplo de Comando y funciones de Aplicaciones de Consola

Module Module1
Sub Main()
‘Declaramos una variable de tipo cadena dcaracteres y 2 variables de
‘tipo numerico
Dim nombre As String
Dim edad, peso As Integer
‘Mostramos un mensaje al usuario
[Link](“Por favor, introduzca su Nombre:”)
‘Capturamos el dato introducido por el usuario
nombre = [Link]()
‘Ingresamos los valores Numericos, Edad y Peso
[Link](“Ingrese la Edad: “)
edad = [Link]
[Link](“Ingrese la Peso: “)
peso = [Link]
‘ Ahora cuando queremos imprimir los datos
[Link](nombre) ‘impresion directa de una variable
[Link](“El nombre ingresado es:{0} “, nombre) ‘acompañado de un texto
‘Impresion de variables dentro de una cadena
[Link](“Mi nombre es {0} y tengo {1} años”, nombre, edad)
‘Cuando se imprimen varias variables se pone un formato de salida {nro}
[Link](“{0}, tiene {1} años y pesa {2}”, nombre, edad, peso)
‘Una pausa a la ejecucion del programa
[Link]()
End Sub
End Module

Observaron el ejemplo utilizando los formatos de ingreso y salida de impresión, es sencillo pero antes
de continuar detallemos algunos conceptos necesarios para poder seguir aprendiendo:

TIPOS, VARIABLES Y ESTRUCTURAS DE CONTROL

En esta segunda lección veremos los tipos de datos que .NET Framework pone a nuestra disposición y
cómo tendremos que usarlos desde Visual Basic 2010.

A continuación daremos un repaso a conceptos básicos o elementales sobre los tipos de datos, que
si bien nos serán familiares, es importante que lo veamos para poder comprender mejor cómo están
definidos y organizados los tipos de datos en .NET.

Visual Basic 2010 está totalmente integrado con .NET Framework, por tanto los tipos de datos que
podremos usar con este lenguaje serán los definidos en este “marco de trabajo”, por este motivo vamos
a empezar usando algunas de las definiciones que nos encontraremos al recorrer la documentación
que acompaña a este lenguaje de programación.

Tipos de Datos.
Los tipos de datos que podemos usar en Visual Basic 2010 son los mismos tipos de datos definidos en
.NET Framework y por tanto están soportados por todos los lenguajes que usan esta tecnología. Estos
tipos comunes se conocen como el Common Type System, (CTS), que traducido viene a significar el
sistema de tipos comunes de .NET.
44 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Tipos primitivos
Veamos en la siguiente tabla los tipos de datos definidos en .NET Framework y los alias utilizados en
Visual Basic 2010.

Las últimas filas mostradas en la tabla son tipos especiales que si bien son parte del sistema de tipos
comunes (CTS) no forman parte de la Common Language Specification (CLS), es decir la especificación
común para los lenguajes “compatibles” con .NET, por tanto, si queremos crear aplicaciones que
puedan interoperar con todos los lenguajes de .NET, esos tipos no debemos usarlos como valores de
devolución de funciones ni como tipo de datos usado en los argumentos de las funciones, propiedades
o procedimientos.
 Capítulo 2: Aprendiendo a conocer Visual Studio 2010 45

Tipos por valor y tipos por referencia

Los tipos de datos de .NET los podemos definir en dos grupos:
1. Tipos por valor
2. Tipos por referencia

Los tipos por valor son tipos de datos cuyo valor se almacena en la pila o en la memoria “cercana”,
como los numéricos que hemos visto. Podemos decir que el acceso al valor contenido en uno de estos
tipos es directo, es decir se almacena directamente en la memoria reservada para ese tipo y cualquier
cambio que hagamos lo haremos directamente sobre dicho valor, de igual forma cuando copiamos
valores de un tipo por valor a otro, estaremos haciendo copias independientes.

Por otro lado, los tipos por referencia se almacenan en el “monto” (heap) o memoria “lejana”, a
diferencia de los tipos por valor, los tipos por referencia lo único que almacenan es una referencia (o
puntero) al valor asignado. Si hacemos copias de tipos por referencia, realmente lo que copiamos es la
referencia propiamente dicha, pero no el contenido.

Declarando y Trabajando con Variables

Las Variables son espacios de memorias que almacenan datos del tipo como se ha definido al momento
de declararla. Visual Basic .Net, como la mayoría de los lenguajes de programación, utiliza variables
para almacenar valores.

Las Constantes también almacenan valores pero, como su nombre lo indica, estos valores permanecen
constantes durante la ejecución de la aplicación.

Formato de Declaración de Variable

[Ambito/DIM] Nom_var AS tipo_dato [= val_ini]

La sentencia DIM es empleada para declarar y asignar valores a las variables. Esta sentencia se puede
emplear a nivel módulos, clases, estructuras, procedimientos o dentro de un bloque de sentencias

Reglas para poner nombres

Empezar con un carácter alfabético o guión bajo
No utilizar espacios ni símbolos
No utilizar palabras clave como Integer, dim, etc.
46 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Forma de Declarar Variables

Con Asignación de Valores

ÁMBITOS Y VISIBILIDAD

Ejemplo:

Para estudiar el modo de trabajo del ámbito con variables, debemos estar familiarizados con los
términos y definiciones de la siguiente tabla:

Término Definición
Ámbito de la Conjunto de código al que se refiere una variable por su nombre asignado
variable sin cualificadores.
Bloque Bloque de código que empieza con una condición como If o While y
termina con una instrucción End, Loop o Next.
Procedimiento Bloque de código que empieza con una instrucción de declaración como
Sub y termina con una instrucción End.
Módulo Archivo que agrupa procedimientos comunes y datos globales para
hacerlos accesibles a su uso en uno o más proyectos.
Ensamblado Un archivo ejecutable independiente en el que se compilan los diversos
archivos cuando genera una solución.
Modificador de Palabra clave como Public o Friend que utilizamos para especificar el nivel
acceso de acceso de una variable o su contenedor (módulo, clase o estructura).
 Capítulo 2: Aprendiendo a conocer Visual Studio 2010 47

Factores que afectan al ámbito

Asignamos el ámbito de una variable cuando la declaramos. Existen tres factores principales que
afectan al ámbito de una variable:

Dónde la declaramos: dentro de un bloque, procedimiento, módulo, clase o estructura.

El nivel de acceso (Public, Friend o Private) del módulo, clase o estructura en que se declara. El ámbito
de una variable no puede exceder el ámbito de su contenedor.

La sintaxis que utilizamos para declarar la variable (Dim, Private, Friend o Public).

Nivel de ámbito Definición

Bloque Disponible únicamente dentro del bloque de código en el que se
declara
Procedimiento Disponible únicamente dentro del procedimiento en el que se declara
Módulo Disponible para todo el código del módulo, clase o estructura en el
que se declara
Espacio de nombres Disponible para todo el código del espacio de nombres

Option Explicit
En general, debería declarar explícitamente las variables de su aplicación antes de utilizarlas. De este
modo, se reduce la probabilidad de errores lógicos y se facilita el mantenimiento del código. Aunque
no es recomendable, puede utilizar variables en su aplicación sin antes declararlas. Este proceso se
denomina declaración implícita.

Cómo funciona Option Explicit

Cuando Option Explicit está On (de forma predeterminada está habilitado), debe declarar
explícitamente variables antes de poder utilizarlas, de lo contrario el compilador generará un error.

Cuando Option Explicit no está habilitado (Off), puede declarar implícitamente una variable
simplemente utilizándola en su código. Se creará como un tipo objeto. Aunque puede resultar
conveniente declarar variables implícitamente, se incrementa la probabilidad de conflictos de nombres
y de un comportamiento imprevisto debido a errores de ortografía. Además, genera un uso ineficaz del
almacenamiento de memoria.

Ejemplo de una ventaja de Option Explicit

Por ejemplo, supongamos que la variable sueldoActual guarda el salario anual de un empleado. Un
procedimiento utiliza esta variable en una fórmula que calcula el bonus del empleado. Supongamos
que la variable sueldoActual se escribe incorrectamente, como se muestra en el siguiente ejemplo:

Dim sueldoActual As Integer

BonusActual = sueldoActual * .10

Con Option Explicit no habilitado (Off), este cálculo supondrá un bonus de $0.00 debido a que la variable
sueldoActual se declarará implícitamente como una nueva variable Object y se inicializará vacía. Cuando
sueldoActual se utilice en el cálculo, Visual Basic lo convertirá automáticamente a 0. Si este cálculo se
realiza varias veces en una estructura cíclica, la aplicación se ejecutará sustancialmente más lentamente
porque Visual Basic necesita tiempo para crear, inicializar, y convertir la variable cada vez.
48 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Configurar Option Explicit

Puede establecer Option Explicit como On u Off a nivel de proyecto del entorno de desarrollo.

Configurar Option Explicit

1. En el Explorador de soluciones, haga clic en el nombre del proyecto para el que desea configurar
Option Explicit.
2. En el menú Ver, haga clic en Páginas de propiedades.
3. Expanda la carpeta Propiedades comunes y, a continuación, haga clic en la carpeta Generar.
4. Bajo Valores predeterminados del compilador, haga clic en Off u On según lo deseado en la lista
Option Explicit y, a continuación, haga clic en OK.

PROGRAMACIÓN ORIENTADA A OBJETOS – POO

Variables Nulas
Declarar la variable como nullable si quiere estar en condiciones de determinar si un valor no ha sido
asignado. Por ejemplo, si está almacenando los datos de un sí / no la cual se hace por una pregunta
sobre un formulario y el usuario no respondieron la pregunta, usted debe almacenar un valor nulo:

Ejemplo

Module Module2
Sub main()
Dim b As Nullable(Of Boolean) = Nothing
If [Link] = True Then
[Link](“La Valor de la Variable b es {0}.”, [Link])
Else
[Link](“El valor de la Variable b no es asignado.”)
End If
[Link]()
End Sub
 Capítulo 2: Aprendiendo a conocer Visual Studio 2010 49

Enumeraciones
Una enumeración es una serie de constantes que están relacionadas entre sí. La utilidad de las
enumeraciones es más manifiesta cuando queremos manejar una serie de valores constantes con
nombre, es decir, podemos indicar un valor, pero en lugar de usar un literal numérico, usamos un
nombre, ese nombre es, al fin y al cabo, una constante que tiene un valor numérico.

En Visual Basic 2010 las enumeraciones pueden ser de cualquier tipo numérico integral, incluso
enteros sin signo, aunque el valor predefinido es el tipo Integer. Podemos declarar una enumeración
de varias formas:

Ejemplo con definición de Tipo

Ejemplo con definición de Asignación

Enum Colores
Rojo
Verde
Azul
End Enum

Ejemplo con definición de Asignación

Enum Color as Byte

Rojo=1
Verde = 2
Azul = 4
End Enum

Ejemplo

Module Module3
Enum Nombres As Integer
Fatima
Yasmyn
Lili
Cristian
Yuri
End Enum
Sub main()
Dim Nom As Nombres = [Link]
[Link](“{0}.”, Nom) ‘ Displaya “Fatima.”
[Link]()
End Sub
End Module
50 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Estructuras
Una estructura es una combinación de tipos de datos que se crea combinando otros tipos de datos. Las
estructuras son de tipo por valor (es decir, una variable de tipo de estructura contiene los datos de la
estructura en lugar de referencia a los datos como hace el tipo referencia).

Las estructuras pueden tener datos, propiedades, métodos y procedimientos y pueden invocar y
manipular eventos.

Grafica de Una Estructura:

Definición de Estructura:

Public Structure Cliente

Public Nombre as String
Public Area as String
Public Perfil as String
Private Codigo as String
Friend Asesor as String
End Structure

Ahora veamos un ejemplo completo de cómo se trabaja una estructura.

Ejemplo de Estructura

Module Module4
Structure Persona
Public Nombre As String
Public Apellido As String
Public edad As Integer
Public Sub New(ByVal _nombre As String, ByVal _apellido As String, _
ByVal _edad As Integer)
Nombre = _nombre
Apellido = _apellido
edad = _edad
End Sub
Public Overloads Overrides Function ToString() As String
Return Nombre + “ “ + Apellido + “,sexo es “ + [Link]
End Function
End Structure
Sub main()
Dim p As Persona = New Persona(“Fatima”, “Sanchez”, 18)
[Link](p)
[Link]()
End Sub
End Module
 Capítulo 2: Aprendiendo a conocer Visual Studio 2010 51

Ahora adicionémosles un dato de tipo Enumerado a esta estructura

Module Module4a
Enum Sexos
Masculino
Femenino
End Enum
Structure Persona
Public Nombre As String
Public Apellido As String
Public edad As Integer
Public sexo As Sexos
Public Sub New(ByVal _nombre As String, ByVal _apellido As String, _
ByVal _edad As Integer, ByVal _sexo As Sexos)
Nombre = _nombre
Apellido = _apellido
edad = _edad
sexo = _sexo
End Sub
Public Overloads Overrides Function ToString() As String
Return Nombre + “ “ + Apellido + “,sexo es “ + sexo + “ [Link]”
End Function
End Structure
Sub main()
Dim p As Persona = New Persona(“Fatima”, “Sanchez”, 18, [Link])
[Link](p)
[Link]()
End Sub
End Module

CLASES EN .NET
Los tipos de datos se dividen en dos grupos: tipos por valor y tipos por referencia. Los tipos por
referencia realmente son clases, de la cuales debemos crear una instancia para poder usarlas, esa
instancia o copia, se crea siempre en la memoria lejana (heap) y las variables lo único que contienen
es una referencia a la dirección de memoria en la que el CLR (Common Language Runtime, motor en
tiempo de ejecución de .NET), ha almacenado el objeto recién creado.

En .NET Framework todo es de una forma u otra una clase, por tanto Visual Basic 2010 también
depende de la creación de clases para su funcionamiento, ya que todo el código que escribamos
debemos hacerlo dentro de una clase.

Creación de Clases en .NET

52 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

OBJECT: LA CLASE BASE DE TODAS LAS CLASES DE .NET

Todas las clases de .NET se derivan de la clase Object, es decir, lo indiquemos o no, cualquier clase
que definamos tendrá el comportamiento heredado de esa clase. El uso de la clase Object como base
del resto de las clases de .NET es la única excepción a la herencia simple soportada por .NET, ya que
de forma implícita, todas las clases de .NET se derivan de la clase Object independientemente de que
estén derivadas de cualquier otra.

De los miembros que tiene la clase Object debemos resaltar el método ToString, este método está
pensado para devolver una representación en formato cadena de un objeto.

DEFINIR UNA CLASE

En Visual Basic 2010, todo el código que queramos escribir, lo tendremos que hacer en un fichero con
la extensión .vb, dentro de ese fichero es donde escribiremos nuestro código, el cual, tal como dijimos
anteriormente siempre estará incluido dentro de una clase, aunque un fichero de código de VB puede
contener una o más clases, es decir, no está limitado a una clase por fichero.

En Visual Basic 2010 las clases se definen usando la palabra clave Class seguida del nombre de la clase,
esa definición acaba indicándolo con End Class.

Los miembros de una clase

Una clase puede contener cualquiera de estos elementos (miembros):
• Enumeraciones
• Campos
• Métodos (funciones o procedimientos)
• Propiedades
• Eventos

Aquí una breve descripción:

Los campos
Son variables usadas para mantener los datos que la clase manipulará.

Los métodos
Son las acciones que la clase puede realizar, normalmente esas acciones serán sobre los datos que
contiene. Dependiendo de que el método devuelva o no un valor, podemos usar métodos de tipo
Function o de tipo Sub respectivamente.
 Capítulo 2: Aprendiendo a conocer Visual Studio 2010 53

Las propiedades
Son las “características” de las clases y la forma de acceder “públicamente” a los datos que contiene.
Por ejemplo, podemos considerar que el nombre y los apellidos de un cliente son dos características
del cliente.

Los eventos
Son mensajes que la clase puede enviar para informar que algo está ocurriendo en la clase.

Esquema de una Clase:

Uso de la clase:

Comparación entre un Tipo por Valor y un Tipo por Referencia

Los tipos por referencia almacenan la dirección de memoria en la que se encuentran un dato
determinado de manera que usaremos esa dirección de memoria para acceder de forma directa al
dato. Los tipos por valor almacenan datos a los que se puede acceder en forma directa. Para entender
esto mostramos este ejemplo, pero antes debemos indicar que una estructura es por valor y una clase
es por referencia

Una estructura es un tipo de dato por valor el cual genera un nuevo espacio de memoria para cada
variable que instancia dicho objeto, en el caso de una clase lo que se realiza es generar una variable
que contenga la misma dirección que la variable original.
54 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ejemplo – Trabajando con valores de TIPO VALOR

Module Module5
Structure Numbers
Public val As Integer
Public Sub New(ByVal _val As Integer)
val = _val
End Sub
Public Overloads Overrides Function ToString() As String
Return [Link]
End Function
End Structure
Sub main()
Dim n1 As Numbers = New Numbers(0)
Dim n2 As Numbers = n1
[Link] += 1 : [Link] += 2
[Link](“n1 = {0}, n2 = {1}”, n1, n2)
[Link]()
End Sub
End Module

Este ejercicio me debe dar como Respuesta n1=1 y n2=2, ahora nosotros cambiemos la palabra
structure y pongamos la palabra class, que quede de esta manera:

Ejemplo – Trabajando con valores de TIPO REFERENCIA

Module Module6
Class Numbers
Public val As Integer
Public Sub New(ByVal _val As Integer)
val = _val
End Sub
Public Overloads Overrides Function ToString() As String
Return [Link]
End Function
End Class
Sub main()
Dim n1 As Numbers = New Numbers(0)
Dim n2 As Numbers = n1
[Link] += 1 : [Link] += 2
[Link](“n1 = {0}, n2 = {1}”, n1, n2)
[Link]()
End Sub
End Module

Al ejecutar el ejercicio con este cambio, nos daremos cuenta que los valores devueltos son n1=3 y
n2=3, esto ocurre porque una clase trabaja con las direcciones de las variables, es decir que las 2
variables apuntan a la misma dirección.

Herencia
Las clases derivadas heredan y pueden extender, las propiedades, métodos y eventos de la clase base.
Las Clases derivadas también pueden reemplazar métodos heredados con nuevas implementaciones.
De forma predeterminada, todas las clases creadas con Visual Studio .Net se pueden heredar.

La Herencia permite escribir y depurar una clase una vez, y después volver a utilizar ese código una y
otra vez como base de nuevas clases.
 Capítulo 2: Aprendiendo a conocer Visual Studio 2010 55

La Herencia también permite utilizar el polimorfismo basado en la herencia, la posibilidad de definir

clases que puedan utilizarse de forma intercambiable mediante código cliente en tiempo de ejecución,
pero con funcionalidad diferente, incluso con métodos o propiedades denominados de manera idéntica.

Las Clases que sirven de base de nuevas clases se denominan Clases base. Las Clases que se derivan de
clases base de denominan Clases Derivadas.

Las Clases Derivadas Heredan todos los campos, propiedades, métodos y eventos definidos en la clase
base. Esto Significa que puede desarrollar y depurar una clase una vez y reutilizar después como base
de otras clases.

Ahora entendamos con un ejemplo como trabaja la herencia:

Creamos la clase VIDEO

Public Class Video
Private strId As String
Private strTitulo As String
Private strPrecio As Single
Public Property ID() As String
Get
Return strId
End Get
Set(ByVal value As String)
strId = value
End Set
End Property
Public Property Titulo As String
Get
Return strTitulo
End Get
Set(ByVal value As String)
strTitulo = value
End Set
End Property
Public Property Precio As Single
Get
Return strPrecio
End Get
Set(ByVal value As Single)
strPrecio = value
End Set
End Property
End Class

Ahora vamos a heredar la clase VIDEO a la clase DVD

Public Class DVD
Inherits Video
Private bMultipesPista As Boolean
Public Property MultiplePista() As Boolean
Get
Return bMultipesPista
End Get
Set(ByVal value As Boolean)
bMultipesPista = value
End Set
End Property
End Class
56 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ahora utilizaremos las clases que hemos creado y heredado

Module Module5
Sub Main()
Dim basicVideo As New Video
With basicVideo
.ID = “12345”
.Titulo = “Video”
.Precio = 15
End With
Dim dvdVideo As New DVD
With dvdVideo
.ID = “12345-1”
.Titulo = “DVD Prueba 1”
.Precio = 7
.MultiplePista = True
End With

[Link](“Video Basico”)
With basicVideo
[Link](“ID = {0} Titulo = {1} Precio = {2}”, .ID, .Titulo, .Precio)
End With

With dvdVideo
[Link](“ID = {0} Titulo = {1} Precio = {2} Pista = {3}”, .ID,
.Titulo, .Precio, .MultiplePista)
End With
[Link]()
End Sub
End Module

APLICACIONES WINDOWS
Formularios Windows
Las aplicaciones de escritorio son aquellas basadas en ventanas y controles comunes de Windows que
se ejecutan en local. Son el mismo tipo de aplicaciones que antes construiríamos con Visual [Link]
2003, 2005 o 2008 u otros entornos similares.

En la plataforma .NET el espacio de nombres que ofrece las clases necesarias para construir aplicaciones
de escritorio bajo Windows se denomina Windows Forms. Este es también el nombre genérico que se
le otorga ahora a este tipo de programas basados en ventanas.

Windows Forms está constituido por multitud de clases especializadas que ofrecen funcionalidades
para el trabajo con ventanas, botones, rejillas, campos de texto y todo este tipo de controles habituales
en las aplicaciones de escritorio.

Un formulario es como se indicó antes una ventana típica de Windows. Estos están contenidos en
forma automática en el Escritorio de Windows o es su defecto dentro de otros formularios a los que
llamaremos formularios MDI (por sus siglas del inglés Multiple Document Interface, que significa
interfaz de múltiples documentos).
 Capítulo 2: Aprendiendo a conocer Visual Studio 2010 57

Toda ventana es a su vez una interfaz gráfica de usuario la que permite interactuar a un usuario no muy
experimentado de una manera muy simple con ella. Cada una de estas interfaces puede tener una gran
funcionalidad inherente la que se concentra en la misma ventana o en determinados controles que
están inmersos en ella.

Las aplicaciones de los formularios de Windows se pueden escribir en cualquiera de los lenguajes de
programación visual compatibles con Common Language Runtime. Sin embargo en éste libro se van a
tratar los que se construyen usando Visual Basic .net únicamente.

Como todo objeto un formulario posee propiedades y métodos así como a su vez soporta eventos.

Visual Studio ofrece todo lo necesario para crear visualmente este tipo de programas, de un modo
similar aunque más rico al que ofrecía el entorno de desarrollo integrado de Visual Basic.

Visual [Link] proporciona control sobre todos los aspectos de las ventanas y controles, no dejando
nada fuera del alcance del programador y otorgando por lo tanto la máxima flexibilidad. Los formularios
(ventanas) son clases que heredan de la clase base Form, y cuyos controles son miembros de ésta. De
hecho se trata únicamente de código y no es necesario (aunque sí muy recomendable) emplear el
diseñador gráfico de Visual Studio para crearlas.
58 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Este es el aspecto que presenta parte del código que genera la interfaz mostrada en la anterior figura:

Código autogenerado por Visual Studio para crear la interfaz de la figura anterior

Creando Proyecto Inicial de una Aplicación Windows

Empecemos creando un proyecto de tipo aplicación Windows, sera de la siguiente manera:
 Capítulo 2: Aprendiendo a conocer Visual Studio 2010 59

Bueno ahora empezaremos a crear formularios, tomaremos los controles básicos, de los cuales iremos
describiendo sus propiedades más importantes. La idea es empezar a conocer los controles con los
cuales contamos en Visual [Link] 2010

Utilizaremos los Controles comunes que se utilizan cuando se inicia la programación.

Ejemplo de Manejo de Controles Iniciales

Primero empezaremos describiendo algunas de las propiedades (más importantes) del formulario:
60 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Algunas propiedades:

(Name) Permite identificar el formulario.

AllowDrop Determina si el control recibe notificaciones de arrastrar y colocar.
AcceptButton Botón Aceptar del formulario. Si está establecido, el botón se ‘activa’
cuando el usuario presiona la tecla [Enter]([INTRO]).
AutoScale Si es igual a True, el formulario ajusta automáticamente la fuente de la
pantalla.
AutoScroll Determina si aparecen automáticamente las barras de desplazamiento
cuando los controles están situados fuera del área de clientes del formulario.
Backcolor Color de fondo utilizado para mostrar texto y gráficos en el control.
BackGroundImage Imagen de fondo utilizada para el formulario.
CancelButton Botón Cancelar del formulario. Si está establecido, el botón se ‘activa’
cuando el usuario presiona la tecla ‘ESC’.
CausesValidation Indica si este control causa y genera eventos de validación.
ContextMenu Menú contextual que se muestra cuando el usuario hace clic con el botón
derecho en el formulario.
ControlBox Determina si el formulario tiene un cuadro de menú Control el que se
encuentra en la esquina superior derecha de toda ventana.
Cursor Cursor que aparece al pasar el mouse por el control
DrawGrid Indica si se debe dibujar la cuadrícula de posición.
Enabled Indica si el control está habilitado.
Font Fuente utilizada para mostrar texto en el control. Permite modificar, como
ejemplo: Name: Es el nombre de la fuente, Size: Tamaño de la fuente, etc.
ForeColor Color de primer plano utilizado para mostrar texto y gráficos en el control.
IsMDIContainer Determina si el formulario es un contenedor MDI (Aplicaciones que pueden
manejar varios documentos simultáneamente).
Location Posición de la esquina superior izquierda del control respecto del
contenedor.
MaximizeBox Determina si el formulario tiene un cuadro para maximizar en la esquina
superior derecha de la barra de título.
Menu El menú principal del formulario. Debe establecerse en un componente de
tipo MainMenu’.
MinimizeBox Determina si el formulario tiene un cuadro para minimizar en la esquina
superior derecha de la barra de título.
MinimunSize Tamaño mínimo al que se puede ajustar el tamaño del formulario.
Opacity Determina la opacidad o transparencia del formulario; 0% es transparente,
100% es opaco.
ShowInTaskBar Determina si el formulario aparece en la barra de tareas de Windows.
SnapToGrid Determina si los controles ajustan la cuadrícula de posición.
StartPosition Determina la posición del formulario cuando aparece por primera vez.
Text Texto que aparece en la barra de título del formulario
WindowsState Determina el estado visual inicial del formulario.
 Capítulo 2: Aprendiendo a conocer Visual Studio 2010 61

Ahora veamos algunos Métodos importantes del Formulario

Activate - Activa el formulario y le otorga el foco.

BeginInvoke - Sobrecargado. Ejecuta un delegado de forma asincrónica en el subproceso donde se

creó el identificador subyacente del control.

Close - Cierra el formulario.

CreateGraphics - Crea el objeto Graphics para el control

Dispose - Sobrecargado. Libera los recursos utilizados por Component.

DoDragDrop - Inicia una operación de arrastrar y colocar.

EndInvoke - Recupera el valor devuelto por la operación asíncrona representada por el objeto
IAsyncResult que se pasa.

Focus - Establece el foco de entrada en el control.

GetContainerControl - Devuelve el siguiente ContainerControl (en sentido ascendente) de la cadena

de controles principales del control.

GetNextControl - Recupera el siguiente control, hacia delante o hacia atrás, en el orden de tabulación
de controles secundarios.

Invalidate - Sobrecargado. Invalida una región específica del control y hace que se envíe un mensaje
de dibujo al control.

LayoutMdi- Organiza los formularios MDI (interfaz de múltiples documentos) secundarios del
formulario MDI principal.

RectangleToClient - Calcula el tamaño y la ubicación del rectángulo de pantalla especificado, en

coordenadas de cliente.

ResetCursor - Restablece el valor predeterminado de la propiedad Cursor.

ResetFont- Restablece el valor predeterminado de la propiedad Font.

ResetForeColor - Restablece el valor predeterminado de la propiedad ForeColor.

ResetImeMode - Restablece el valor predeterminado de la propiedad ImeMode.

ResetRightToLeft - Restablece el valor predeterminado de la propiedad RightToLeft.

ResetText - Restablece el valor predeterminado de la propiedad Text.

ResumeLayout - Sobrecargado. Reanuda la lógica de diseño habitual.

Scale - Sobrecargado. Ajusta la escala del control y de todos los controles secundarios.
62 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Select - Sobrecargado. Activa un control.

SelectNextControl - Activa el siguiente control.

SendToBack - Envía el control al final del orden Z.

Show- Muestra el control al usuario.

ShowDialog - Sobrecargado. Muestra el formulario como un cuadro de diálogo modal.

SuspendLayout - Suspende temporalmente la lógica de diseño del control.

ToString - Reemplazado. Por el objeto [Link].

Update - Hace que el control vuelva a dibujar las regiones no válidas en su área de cliente.

Validate - Valida el último control no validado y sus predecesores, pero sin incluir el control actual.

Ahora veamos algunos Eventos de un Formulario

Activated - Se produce cuando el formulario se activa por código de programa o por parte del usuario.

BackColorChanged - Se produce cuando el valor de la propiedad BackColor cambia.

BindingContextChanged- Se produce cuando el valor de la propiedad BindingContext cambia.

CausesValidationChanged - Se produce cuando el valor de la propiedad CausesValidation cambia.

Clic - Se produce cuando se hace clic en el control.

Closed - Tiene lugar cuando el formulario está cerrado.

Closing - Tiene lugar cuando se cierra el formulario.

CursorChanged - Se produce cuando el valor de la propiedad Cursor cambia.

Deactivate - Se produce cuando el formulario pierde el foco y no es el formulario activo.

DoubleClick - Se produce cuando se hace doble clic en el control.

DragDrop- Se produce cuando termina una operación de arrastrar y colocar.

DragEnter - Se produce cuando se arrastra un objeto dentro de los límites del control.

DragLeave - Se produce cuando se arrastra un objeto fuera de los límites del control.

DragOver - Se produce cuando se arrastra un objeto sobre los límites del control.

EnabledChanged - Se produce cuando cambia el valor de la propiedad Enabled.

Enter - Se produce cuando se entra en el control.

 Capítulo 2: Aprendiendo a conocer Visual Studio 2010 63

FontChanged- Se produce cuando cambia el valor de la propiedad Font.

ForeColorChanged - Se produce cuando cambia el valor de la propiedad ForeColor.

GotFocus - Se produce cuando el control recibe el foco.

Invalidated - Se produce cuando es necesario volver a dibujar un control.

KeyDown - Se produce cuando se presiona una tecla mientras el control tiene el foco.

KeyPress - Se produce cuando se presiona una tecla mientras el control tiene el foco.

KeyUp - Se produce cuando se suelta una tecla mientras el control tiene el foco.

Layout - Se produce cuando un control debe volver a colocar sus controles secundarios.

Leave - Se produce cuando el foco de entrada deja el control.

Load - Se produce antes de que se muestre un formulario por primera vez.

LocationChanged - Se produce cuando cambia el valor de la propiedad Location.

LostFocus - Se produce cuando el control pierde el foco.

MaximizedBoundsChanged - Se produce cuando cambia el valor de la propiedad MaximizedBounds.

MaximumSizeChanged - Se produce cuando cambia el valor de la propiedad MaximumSize.

MenuStart - Se produce cuando el menú de un formulario recibe el foco.

MinimumSizeChanged - Se produce cuando cambia el valor de la propiedad MinimumSize.

MouseDown - Se produce cuando el puntero del mouse está sobre el control y se presiona un botón
del mouse.

MouseEnter - Se produce cuando el puntero del mouse entra en el control.

MouseHover - Se produce cuando el puntero del mouse se sitúa encima del control.

MouseLeave - Se produce cuando el puntero del mouse deja el control.

MouseMove - Se produce cuando el puntero del mouse se mueve sobre el control.

MouseUp - Se produce cuando el puntero del mouse está encima del control y se suelta un botón del
mouse.

MouseWheel- Se produce cuando la rueda del mouse se mueve mientras el control tiene el foco.

Move - Se produce cuando se mueve el control.

ParentChanged- Se produce cuando cambia el valor de la propiedad Parent.

64 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Resize - Se produce cuando se cambia el tamaño del control.

TextChanged - Se produce cuando cambia el valor de la propiedad Text.

Validated - Se produce cuando finaliza la validación del control.

Validating - Se produce cuando el control se está validando.

En el ejemplo siguiente vamos a utilizar controles, ahora describiremos algunos de los controles más
utilizados que se encuentran en la barra de herramienta.

Bueno ahora que hemos conocido todos las Propiedades, Eventos y Métodos de los cuales está
compuesto un formulario, empecemos con el diseño, para esto debemos conocer los diferentes
controles con los cuales contamos, los mostraremos en forma rápida:

Controles
Función Control Descripción
Edición de texto TEXTBOX Muestra texto escrito en tiempo de diseño que
puede ser editado por los usuarios en tiempo
de ejecución o ser modificado mediante
programación.
RICHTEXTBOX Habilita la presentación del texto con formato
de texto sencillo o de texto enriquecido (RTF).
Presentación de LABEL Muestra texto que los usuarios no pueden
texto (sólo lectura) modificar directamente.
LINKLABEL Muestra texto en forma de vínculo de estilo Web
y desencadena un evento cuando el usuario
hace clic en el texto especial. Habitualmente, el
texto es un vínculo a otra ventana o a un sitio
Web.
STATUSBAR Muestra información acerca del estado actual
de la aplicación mediante una ventana con
marco, habitualmente en la parte inferior de
un formulario primario.
Selección de una CHECKEDLISTBOX Muestra una lista desplazable de elementos,
lista cada uno acompañado por una casilla de
verificación.
COMBOBOX Muestra una lista desplegable de elementos.

DOMAINUPDOWN Muestra una lista de elementos de texto a través

de la cual los usuarios se pueden desplazar
mediante botones hacia arriba y hacia abajo.
LISTBOX Muestra una lista de texto y elementos gráficos
(iconos).
LISTVIEW Muestra los elementos por medio de una de
cuatro vistas diferentes. Las vistas son Sólo
texto, Texto con iconos pequeños, Texto con
iconos grandes y una vista Detalles.
 Capítulo 2: Aprendiendo a conocer Visual Studio 2010 65

Selección de una NUMERICUPDOWN Muestra una lista de números a través de la

lista cual los usuarios se pueden desplazar mediante
botones hacia arriba y hacia abajo.
TREEVIEW Muestra una colección jerárquica de objetos de
nodo que pueden constar de texto con casillas
de verificación o iconos opcionales.
Presentación de PICTUREBOX Muestra archivos gráficos, tales como mapas
gráficos de bits e iconos, en un marco.
Almacenamiento IMAGELIST Sirve como repositorio de imágenes. Los
de gráficos controles ImageList y las imágenes que
contienen pueden reutilizarse de una aplicación
a la siguiente.
Establecimiento de CHECKBOX Muestra una casilla de verificación y una
valores etiqueta para texto. Se utiliza en general para
establecer opciones.
CHECKEDLISTBOX Muestra una lista desplazable de elementos,
cada uno acompañado por una casilla de
verificación.
RADIOBUTTON Muestra un botón que puede activarse o
desactivarse.
TRACKBAR Permite que los usuarios establezcan valores
mediante el desplazamiento de un control de
posición a lo largo de una escala.
Establecimiento de DATETIMEPICKER Muestra un calendario gráfico que permite que
fechas los usuarios seleccionen una fecha o una hora.
Establecimiento de MONTHCALENDAR Muestra un calendario gráfico que permite que
fechas los usuarios seleccionen un intervalo de fechas.
Cuadros de diálogo COLORDIALOG Muestra el cuadro de diálogo de selección
de colores, que permite que los usuarios
seleccionen el color de un elemento de la
interfaz.
FONTDIALOG Muestra un cuadro de diálogo que permite
que los usuarios establezcan una fuente y sus
atributos.
OPENFILEDIALOG Muestra un cuadro de diálogo que permite que
los usuarios se desplacen hasta un archivo y lo
seleccionen.
PRINTDIALOG Muestra un cuadro de diálogo que permite que
los usuarios seleccionen una impresora y sus
atributos.
PRINTPREVIEWDIALOG Muestra un cuadro de diálogo que muestra
cómo aparecerá un objeto PrintDocument al
imprimirse.
SAVEFILEDIALOG Muestra un cuadro de diálogo que permite que
los usuarios guarden un archivo.
66 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Controles de menú MAINMENU Proporciona una interfaz en tiempo de diseño

para la creación de menús.
CONTEXTMENU Implementa un menú que aparece cuando el
usuario hace clic en un objeto con el botón
secundario del mouse (ratón).
Comandos BUTTON Se utiliza para iniciar, detener o interrumpir un
proceso.
LINKLABEL Muestra texto en forma de vínculo de estilo Web
y desencadena un evento cuando el usuario hace
clic en el texto especial. Habitualmente, el texto
es un vínculo a otra ventana o a un sitio Web.
NOTIFYICON Muestra un icono, en el área de notificación de
estado de la barra de tareas, que representa una
aplicación que se ejecuta en segundo plano.
TOOLBAR Contiene una colección de controles botón.
Agrupar otros PANEL Agrupa un conjunto de controles en un marco
controles sin etiqueta que permite el desplazamiento.
GROUPBOX Agrupa un conjunto de controles (tales como
botones de opción) en un marco con etiqueta,
que no permite el desplazamiento.
TABCONTROL Proporciona una página con fichas para
organizar y tener acceso a controles agrupados
de forma eficiente.

Formulario de Ejemplo
Ahora desarrollemos el primer ejemplo, en cual desarrollaremos una ventana de seguridad, la cual nos
pedirá un usuario y una clave, además de eso podemos cambiar de idioma.

Ahora si empecemos a diseñar el primer Winforms, el formulario de acceso a todo nuestro aplicativo
 Capítulo 2: Aprendiendo a conocer Visual Studio 2010 67

Ahora realicemos las siguientes modificaciones a las propiedades de los Siguientes controles:

Control Propiedad Valor

Label1 (name) lblTitulo
Text Acceso al Sistema
Label2 (name) lblUsuario
Text Usuario:
Label3 (name) lblClave
Text Clave:
Label4 (name) Lblidioma
Text English
Textbox1 (name) txtUsuario
Textbox2 (name) txtClave
PasswordChar *
CharacterCasing Upper
btnAceptar (name) btnAceptar
Text &Aceptar
btnCerrar (name) btnCerrar
Text &Cerrar

Ahora veamos como hemos modificado el script a través de los eventos:

Public Class Form1

‘Declaramos 2 variables de tipo string
Dim Usuario As String = “Fatima”
Dim Clave As String = “FYSH”

Private Sub btnAceptar_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
‘Validacion de Usuario y Clave Ingresada, para el Acceso
If [Link] = Usuario Then
If [Link] = Clave Then
[Link](“El Usuario y la Clave es Correcta!!!”, “OK Acceso”)
[Link] = False : [Link] = False
[Link] = False
Else ‘Si la Clave es incorrecta
[Link](“La clave es Incorrecta!!!!”, “NO Acceso”)
[Link]() ‘Limpia el control
[Link]() ‘Envia el foco al control
End If
Else ‘ Si el usuario es Incorrecto
[Link](“El Usuario es Incorrecta!!!!”, “NO Acceso”)
[Link]() : [Link]() ‘Limpia el control
[Link]() ‘Envia el foco al control
End If
End Sub
68 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Private Sub btnCerrar_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
‘Cerrar la ventana
Close()
End Sub

Private Sub lblidioma_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
‘Cambiar de Idioma la ventana de Acceso al formulario
If [Link] = “English” Then ‘Cuando quiero convertir todo a Idioma Ingles
[Link] = “User:” : [Link] = “Password:”
[Link] = “System Access”
[Link] = “OK” : [Link] = “Close”
[Link] = “Espanol”
Else
[Link] = “Usuario:” : [Link] = “Clave:”
[Link] = “Acceso al Sistema”
[Link] = “Aceptar” : [Link] = “Cerrar”
[Link] = “English”
End If
End Sub
End Class

Listo, hicimos nuestro primer Ejercicio pero todavía nos quedan algunas dudas, como por ejemplo las
propiedades mas importantes de los controles Label, Textbox y button, que son las propiedades que
pasamos a detallar:

VENTANA DE PROPIEDADES
 Capítulo 2: Aprendiendo a conocer Visual Studio 2010 69

Propiedades Comunes importantes de controles Label, Textbox y Button

Propiedades Texto Control

Name Nombre del control Label, textbox y button
AllowDrop Por defecto esta en False, en True Label, textbox y button
permite que se haga un soltado sobre
el control
Backcolor Color de Fondo del control Label, textbox y button
BorderStyle Estilo del borde del control Label y textbox
Cursor Forma de cursor que va tomar cuando Label, textbox y button
este sobre el control
Dock Permite al control poder adaptarse a un Label, textbox y button
ancho determinado del formulario
Enabled Permite controlar la habilitacion, 2 Label, textbox y button
valores true false
Font Permite controlar todo lo referente al Label, textbox y button
color, tipo, tamaño de la letra
Forecolor Color de los caracteres del control Label, textbox y button
TabIndex Valor de indice de cada control Label, textbox y button
Text Texto que aparecera en el control Label, textbox y button
TextAlign Alineación del texto ingresado en el Label, textbox y button
control
Visible Visualizacion del control Label, textbox y button

Propiedades Importantes del Textbox

Propiedades Texto
Maxlength Cantidad maxima de caracteres que se pueden ingresar en un control
PasswordChar Carácter que aparece como mascara cuando se ingresa cualquier tipo
de texto
ReadOnly Convierte al control en deshabilitado, pero permite poder seleccionar
el texto que exista en el control
Scrollbar Permite ponerle scroll al control
WordWrap Indica si un control de cuadro de texto multilínea ajusta las palabras
de forma automática al principio de la línea siguiente cuando es
necesario.

Que tal le gusto este primer ejemplo, sencillo no… entendamos algo un objeto siempre va a tener
Propiedades, Métodos y Eventos, nosotros siempre mas a trabajar sobre esto. Para entender mejor
lo que quiero decir hagamos un segundo formulario, esta vez utilicemos un nuevo control llamado
Listbox
70 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Propiedades importantes del control Listbox

Propiedades Texto
Name Nombre del control
AllowDrop Por defecto esta en False, en True permite que se haga un soltado
sobre el control
Backcolor Color de Fondo del control
BorderStyle Estilo del borde del control
Cursor Forma de cursor que va tomar cuando este sobre el control
DataSource Origen de Data, cuando se desea recuperar información de una
base de datos
DisplayMenber El dato a mostrar de la recuperación de datos efectuadas con la
propiedad DataSource
Ítems
Sorted Ordenar los ítem que se encuentran ingresados en un Listbox,
puede tener 2 valores true/false
SelectionMode Forma de poder seleccionar los ítems de un listbox, selección
única, selección múltiple, etc.
Dock Permite al control poder adaptarse a un ancho determinado del
formulario
Enabled Permite controlar la habilitación, 2 valores true/false
Font Permite controlar todo lo referente al color, tipo, tamaño de la
letra

Métodos Importantes del control Listbox

Metodo Definicion
[Link] Contiene propiedades sobre la administración de los elementos
agregados al Listbox
[Link] Permite adicionar elementos dentro de un Listbox.
[Link] Permite eliminar todos los elementos de un Listbox.
[Link] Permite eliminar el elemento seleccionado, para esto necesita el
valor del elemento seleccionado
[Link] Permite eliminar el elemento seleccionado, para esto necesita el
valor del índice seleccionado
[Link] Devuelve el valor del elemento seleccionado.
[Link] Devuelve el valor del índice del elemento seleccionado (devuelve
-1 sino se selecciono ninguno).
[Link] Devuelve la cantidad de registros que tiene el listbox
 Capítulo 2: Aprendiendo a conocer Visual Studio 2010 71

Ejemplo con Listbox – Ejemplo Inicial

Diseñaremos el siguiente formulario

Control Propiedad Valor

Label text Nombre
Textbox (name) txtNombre
Listbox (name) lstNombre
Button (name) btnAgregar
Text Agregar
Button (name) btnEliminar
Text Eliminar

Cuando queramos movernos entre el código y el diseño debemos seleccionar “Ver Código”, la pantalla
a mostrar será la siguiente:

Seleccionar el control a generar el evento

72 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Seleccionar el Evento a codificar:

Descripción de un Evento
En este caso al seleccionar aparecerá en la clase el siguiente evento:

Los eventos producidos por los controles agregados a un formulario tiene la siguiente estructura:

[Ambito] Sub Button_Click ([Argumentos y Eventos]) Handles Button.[Evento]

El nombre Button_Click solo es una sugerencia que Visual Basic realiza, en las versiones anteriores no
era una sugerencia, era una imposición que nos hacia.

Ahora podemos dejar el nombre que aparece o podemos poner un nombre adecuado nosotros
mismos; lo importante aquí es la parte final de la línea de declaración del procedimiento: Handles
[Link], con esto es que el compilador de Visual Basic sabe que es un evento y que dicho
evento pertenece al objeto btnAgregar.

Para esto seleccionamos el evento Clic, en el cual escribiremos lo siguiente:

Private sub btnAgregar_Click(Byval sender as [Link]

Dim Nombre as String
Nombre = [Link]
[Link](Nombre)
End Sub

Luego, en el botón eliminar, escribimos:

Private sub btnEliminar_Click(Byval sender as [Link]

Dim Nombre as String
Nombre = [Link]
[Link](NJombre)
End Sub

OBS: la palabra reservada Me hace referencia a la clase actual, es decir al formulario que estas
codificando.
 Capítulo 2: Aprendiendo a conocer Visual Studio 2010 73

Finalmente, ejecutemos nuestro proyecto con F5 o desde el menú Debug en Ejecutar, el cual tendremos
lo siguiente:

Propiedades Interesantes sobre el Diseño de Windows Forms.

Anchor: Permite a los controles dentro de un formulario adaptarse al cambio de tamaño producido
por el formulario, para que el diseño de los controles dentro de este se mantenga alineado según se
modifique, para esto contiene propiedades de crecimiento: Top, Left, Right y Bottom.

Cambiemos la configuración de los controles dentro del formulario frmControles, para que cuando
cambiemos el tamaño del formulario el diseño se mantenga:

Antes

Ahora
74 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Dock: Indica la ubicación de los controles dentro del formulario, es decir los controles agregados al
formulario se acoplan según la ubicación deseada hasta ocupar todo el espacio del formulario.

Alineación
Superior

Se alinea a Se alinea a
la Izquierda la Derecha

Rellena todo
el espacio
Alineación
Inferior

XII.- Para terminar bien nuestra aplicación, una buena costumbre es tener uniformizados los nombres
de clases con los archivos que lo van a contener:

Para esto seleccionamos el formulario del explorador de soluciones, y cambiamos el nombre a

[Link]

Ejemplo de manejo de Fechas

Bien empezaremos trabajando con un formulario que me permita trabajar las fechas, para esto
utilizaremos los controles como el textbox, adicionalmente utilizaremos el control timer. El formulario
tendrá el siguiente formato:
 Capítulo 2: Aprendiendo a conocer Visual Studio 2010 75

Empezaremos trabajando con el código:

Private Sub frmFechas_Load(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
‘Now - es una funcion que captura la fecha y hora actual del computador
‘Format - permite darle un formato al dato de salida
[Link] = Format(Now(), “dd/MM/yyyy”)
[Link] = Format(Now(), “hh:mm:ss:tt”)
End Sub

Ahora codificaremos el evento TICK del control Timer, para esto modificamos la Propiedad Enabled =
true y la propiedad Interval = 1000

Private Sub Timer1_Tick(ByVal sender As [Link], ByVal e As [Link])

Handles [Link]
‘Se ejecuta por cada intervalo que ocurre
[Link] = Format([Link], “hh:mm:ss tt”)
End Sub

Ahora el Evento Click del Botón Calcular

Private Sub btnCalcular_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Dim mes, dia, tiempo As Integer
‘si los datos han sido ingresados correctamente
If [Link] > 0 And [Link] > 0 Then
mes = [Link]
dia = [Link]
tiempo = ((mes * 30) - 30) + dia
[Link] = tiempo
Else
MsgBox(“Falta Ingresar el Dia o el Mes, Verificar po Favor”)
[Link]()
End If
End Sub

El resultado sería de la siguiente manera:

76 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ejercicio – Generación de tablas – Utilizando ListBox

Ahora realizaremos un ejemplo que permita utilizando controles Listbox y sentencias repetitivas, el
diseño del formulario es de la siguiente manera:

El script seria de la siguiente manera:

En el evento load:

Private Sub frmGen_tabla_Load(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Dim N As Integer
For N = 1 To 12
[Link]([Link])
Next
End Sub

Ahora el script en los botones

Private Sub btnGenerar_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Dim N, I, R, NUMERO As Integer
[Link]()
For N = 0 To 11
If [Link](N) Then
NUMERO = N + 1
For I = 1 To 12
R = NUMERO * I
[Link](NUMERO & “ * “ & I & “ = “ & R)
Next
End If
Next
End Sub
Private Sub btnQuitar_Click(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
[Link] = -1
[Link]()
End Sub
 Capítulo 2: Aprendiendo a conocer Visual Studio 2010 77

El resultado final sería así:

Ejercicio – Trabajando con ListBox

Vamos a realizar un ejemplo, trabajando con el ListBox, para esto desarrollamos el siguiente formulario:

Ahora veamos el script para este formulario:

Private Sub frmListbox_Load(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
‘Deshabilitar los controles de Adicionar y Eliminar
[Link] = False
[Link] = False
End Sub
78 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Valida el campo txtDato para activar los botones

Private Sub txtDato_TextChanged(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
‘Este evento se ejecuta cuando se modifica el texto del control
‘Activando o Desactivand o en Boton Agregar
If Len([Link]) > 0 Then ‘Len - calcula la longitud
[Link] = True ‘habilito el control
Else ‘Si la longitud es igual a cero
[Link] = False ‘Deshabilito el control
End If
End Sub

Ahora codificamos los siguientes controles

Private Sub BtAdd_Click(ByVal sender As [Link], ByVal e As [Link])

Handles [Link]
‘Boton Añadir
If [Link] > 0 Then
[Link]([Link]) ‘Adicionando en el Listbox
[Link]()
Else
MsgBox(“No se Ingreso el Dato”)
End If
[Link]() ‘Deja el cursor en el control
End Sub
Private Sub lstDatos_SelectedIndexChanged(ByVal sender As [Link], ByVal
e As [Link]) Handles [Link]
If [Link] >= 0 Then ‘Para saber si esta marcado
[Link] = [Link] ‘Captura el Items Seleccionado
[Link] = [Link]([Link]) ‘El dato
selecccionado
[Link] = [Link] ‘la cantidad de items que existen
[Link] = True ‘habilita el control de eliminar
End If
End Sub
Private Sub BTRem_Click(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
‘Boton Remover
‘SelectedIndex - devuelve el numero del indice seleccionado
If [Link] <> -1 Then
[Link]([Link]) ‘elimina por el indice
‘[Link]([Link])’elimina por el texto
[Link] = [Link] ‘Contabiliza los Items
[Link] = “”
[Link] = “”
Else ‘Si es igual a -1
MsgBox(“No existe Nada Seleccionado”)
End If
End Sub
 Capítulo 2: Aprendiendo a conocer Visual Studio 2010 79

Limpia los controles del formulario

Private Sub BtClr_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
‘Boton Limpiar
‘Limpiar todos los controles
[Link]() ‘Limpia todos los Items del Listbox
[Link]()
[Link] = “”
[Link] = “”
[Link] = “”
End Sub

El resultado del formulario seria así:

 CAPÍTULO

3
Estructuras de Control
Condicionales
 CAPÍTULO

3 Estructuras de Control
Condicionales
ESTRUCTURAS DE CONTROL, CONDICIONALES.
SENTENCIA DE CONTROL – IF…THEN…ELSE
Formato 1 - If…then
En general, la instrucción If…Then se utiliza cuando el programa debe evaluar si una instrucción es
verdadera o falsa.

Las instrucciones If…Then evalúan si una condición es verdadera o falsa y dirigen el flujo del programa
en consecuencia.

Formato:
If condition Then
statements
End If

Formato 2 - If…then…else
Una instrucción If…Then…Else incluye los siguientes componentes:
• Una condición que evalúa si es True o False.
• Una o más instrucciones que se ejecutan dependiendo del resultado de la prueba de la condición.
• Una instrucción End If en el caso de un bloque.

Formato:
If condition Then
statements
Else
statements
End If

Formato 3 - Anidar instrucciones If…Then…ElseIf

Podemos utilizar tantas instrucciones If…Then como sean necesarias en una estructura If…Then. Añadir
instrucciones If…Then en una estructura If…Then se denomina anidación.

Formato:
If condition Then
statements
ElseIf condition2 Then
statements
Else
statements
End If
84 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ejemplo de Combinación de todas las sentencias

Otras Formas de Uso de Condicionales.

Ejemplo en aplicación de consola con IF…ELSE

Podemos ver cómo podemos utilizar la condicional para poder administrar la información, ya que
depende de la condición para determinar la información que se va a manejar

Module Module2
Sub main()
[Link](“******Ejemplo 1*********************”)
Dim edad As Integer
[Link](“ingrese su Edad: “) : edad = [Link]
If edad >= 18 Then
[Link](“Es Mayor de Edad....!!!”)
End If
[Link]()
[Link](“*******Ejemplo 2********************”)
Dim peso As Integer
[Link](“ingrese su Peso: “) : peso = [Link]
If peso > 70 Then
[Link](“Esta Subido de Peso..!!!!”)
Else
[Link](“Su Peso es Correcto..!!!!”)
End If
[Link]()
End Sub
End Module
 Capítulo 3: Estructuras de Control - Condicionales 85

Ejemplo de IF anidados
Este ejemplo lo que realiza es ingresar un nombre y una nota, el programa te debe permitir devolver
el mensaje según el rango en el que se encuentre la nota:

Module Module3
Sub main()
Dim nombre, tipo As String
Dim nota As Integer
[Link](“Ingrese su Nombre: “)
nombre = [Link]
[Link](“ingrese su Nota: “)
nota = [Link]
If (nota >= 0) And (nota <= 5) Then
tipo = “Muy Mala”
ElseIf (nota >= 6) And (nota <= 10) Then
tipo = “Mala”
ElseIf (nota >= 11) And (nota <= 14) Then
tipo = “regular”
ElseIf (nota >= 15) And (nota <= 20) Then
tipo = “Bueno”
Else
tipo = “Fuera de Rango”
End If
[Link](“{0} tu nota es {1}”, nombre, tipo)
[Link]()
End Sub
End Module

Forma Comprimida.

Resultado =IIF( [Condición] , [Salida si es Verdad] , [Salida si es Falso] )

Condicionales Múltiples. – SELECT CASE

La instrucción Select Case permite a nuestra aplicación ejecutar uno o varios bloques de código
dependiendo del valor de una expresión de prueba. La instrucción Select Case funciona como una
compleja estructura If…Then…Else anidada, pero su mantenimiento es más sencillo.

Formato del Select Case

86 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ejemplo con la Sentencia SELECT…CASE

Module Module4
Sub main()
Dim Dia As Integer
‘Sentencia de control Multiple
[Link](“Ingrese Numero de Dia a Mostrar: “)
Dia = [Link]
Select Case Dia
Case 1 : [Link](“El dia es Lunes”)
Case 2 : [Link](“El dia es Martes”)
Case 3 : [Link](“El dia es Miercoles”)
Case 4 : [Link](“El dia es Jueves”)
Case 5 : [Link](“El dia es Viernes”)
Case 6 : [Link](“El dia es Sabado”)
Case 7 : [Link](“El dia es Domingo”)
Case Else
[Link](“El Numero del Dia fuera de Rango”)
End Select
[Link]()

End Sub
End Module

Otro Ejemplo de Select…Case

Ejemplo en el cual se va a descomponer un numero de 4 cifras y te mostrara en letras el valor de la
centenas.

Module Module5
Sub main()
‘Se pide Ingresar un Numero de 3 cifras, me debe devolver dicho numero en letra
Dim numero, cen, dec, und, resto As Integer
[Link](“Ingrese Numero[1-999]: “)
numero = [Link]
If numero >= 1 And numero <= 999 Then
cen = numero \ 100 : resto = numero Mod 100
dec = resto \ 10 : und = resto Mod 10
‘Para las Centenas
Select Case cen
Case 1
If (dec = 0) And (und = 0) Then
[Link](“Cien “)
Else
[Link](“Ciento “)
End If
Case 2 : [Link](“DosCientos “)
Case 3 : [Link](“TresCientos “)
Case 4 : [Link](“CuatroCientos “)
Case 5 : [Link](“Quinientos “)
Case 6 : [Link](“SeisCientos “)
Case 7 : [Link](“SeteCientos “)
Case 8 : [Link](“OchoCientos “)
Case 9 : [Link](“NoveCientos “)
End Select
Else
[Link](“El numero fuera del Rango Permitido<1 - 999>”)
End If
[Link]()
End Sub
End Module
 Capítulo 3: Estructuras de Control - Condicionales 87

Un ejemplo más de Select…Case

Este ejemplo utilizando nos mostrara un mensaje según la edad de una persona, veremos otra forma
de comparar valores con el case

Module Module6
Sub Main()
Dim edad As Integer
[Link](“ingrese la Edad: “) : edad = [Link]
Select Case edad
Case 0 To 9 : [Link](“Esta en la Infancia”)
Case 10 To 13 : [Link](“Esta en la Niñez”)
Case 15, 16, 17: [Link](“Esta en la Adolencia”)
Case 18 To 59 : [Link](“Esta en la Adultez”)
Case Is >= 60
[Link](“Esta en la Anciano”)
Case Else : [Link](“La edad No está bien Creada”)
End Select
End Sub
End Module

Ejercicio – Creando una Boleta de Pagos, utilizando sentencias de control Simple y Múltiples
Vamos a crear el siguiente formulario:

Vamos adicionarle un control TIMER, el cual modificaremos las propiedades Enabled = TRUE y la
propiedad INTERVAL = 1000

Ahora vamos a empezar a codificar el formulario

Empecemos con el Evento Tick del control Timer

Private Sub Timer1_Tick(ByVal sender As [Link], ByVal e As [Link])

Handles [Link]
[Link] = Format([Link](), “hh:mmm:ss tt”)
End Sub
88 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ahora el evento Load

Private Sub frmBoleta_Load(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
[Link] = Format(Now(), “dd/mm/yyyy”)
End Sub

Ahora vamos al proceso principal, el boton calcular

Private Sub btnCalcular_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
‘Declaracion de Variables Locales
Dim hb, bons, bonc, st, dcto, neto As Single ‘Entero Corto
Dim ts, categoria As Integer
Dim FecIng As Date
‘Calculo de Haber Basico - Obrero o Empleado
If [Link] = True Then ‘Empleado esta seleccionado
hb = 2000
ElseIf [Link] = True Then ‘Obrero esta seleccionado
hb = 800
End If
‘Calculo el tiempo de Servicio
FecIng = CDate([Link]) ‘Cdate - Convertir a fecha un valor
‘DataDiff - calcula una Intervalo entre una fecha y otra - formato
DateDiff(tipo_intervalo,Fecha1,Fecha2)
ts = DateDiff([Link], FecIng, Now())
‘Calculo de bonificacion de por tiempo de servicio
If ts >= 31 Then : bons = 0.33 * hb
ElseIf ts >= 16 Then : bons = 0.24 * hb
ElseIf ts >= 6 Then
bons = 0.18 * hb
ElseIf ts >= 2 Then
bons = 0.1 * hb
Else : bons = 0
End If
‘Obtener la Categoria – Forma Comprimida
categoria = IIf([Link] = True, 1, IIf([Link] = True, 2, IIf(R5.
Checked = True, 3, _
IIf([Link] = True, 4, IIf([Link] = True, 5, 0)))))
‘Bonificacion por categoria
Select Case categoria
Case 1 : bonc = 0.1 * hb
Case 2 : bonc = 0.13 * hb
Case 3 : bonc = 0.17 * hb
Case 4 : bonc = 0.22 * hb
Case Else : bonc = 0.3 * hb
End Select
‘Calculando el SubTotal
st = hb + bons + bonc
‘Calcular el Descuento
Select Case [Link] ‘Empleado
Case True ‘Si es empleado y esta marcado
Select Case categoria ‘para el empleado
Case 1 : dcto = 0.8 / 100 * hb
Case 2 : dcto = 0.9 / 100 * hb
Case 3 : dcto = 1 / 100 * hb
Case 4 : dcto = 1.5 / 100 * hb
Case 5 : dcto = 2 / 100 * hb
End Select
Case Else ‘Si no esta Marcado, entonces es para obreros
Select Case categoria
Case 1 : dcto = 0.2 / 100 * hb
 Capítulo 3: Estructuras de Control - Condicionales 89

Case 2 : dcto = 0.4 / 100 * hb

Case 3 : dcto = 0.6 / 100 * hb
Case 4 : dcto = 0.8 / 100 * hb
Case 5 : dcto = 1 / 100 * hb
End Select
End Select
neto = st - dcto
[Link] = Format(hb, “#,##0.00”) ‘Sueldo Basico
[Link] = ts ‘Tiempo de Servicio
[Link] = Format(bonc, “#,##0.00”) ‘Bonificacion de categoria
[Link] = Format(bons, “#,##0.00”) ‘Bonificacion de tiempo de servicio
[Link] = Format(st, “#,##0.00”) ‘Sub Total
[Link] = Format(dcto, “#,##0.00”) ‘Descuentos
[Link] = Format(neto, “#,##0.00”) ‘Neto a Pagar
End Sub

El resultado de Formulario será de la siguiente manera:

Constantes en .NET
En Visual [Link] tenemos una gran variedad de constantes que se ha heredado de VB 6.0. Estas
constantes las podemos utilizar y se encuentran en el espacio de nombre [Link].

Estados de una Ventana:

Con los días de la Semana:

90 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Para el resultado de los Mensajes:

Para Trabajar con textos:

Para el Trabajo con archivos:

ESTRUCTURAS DE REPETICIÓN POR CONTADOR

Sentencia For…Next
Un bucle For…Next se ejecuta un determinado número de veces fijado por un contador de bucles. El
valor del contador de un bucle For…Next puede incrementarse o disminuir dependiendo de si step es
positivo o negativo.

La sintaxis de una instrucción For…Next es la siguiente:

For Valor = [Valor Inicial] To [Valor Final]

‘Function Statements
Condición → Exit For
Next

Lo entenderemos mejor con algunos ejemplos:

Dim i As Integer
‘
For i = 1 To 10
‘ contará de 1 hasta 10
‘ la variable i tomará los valores 1, 2, 3, etc.
Next
‘
For i = 1 To 100 Step 2
‘ contará desde 1 hasta 100 (realmente 99) de 2 en 2
 Capítulo 3: Estructuras de Control - Condicionales 91

‘ la variable i tomará los valores 1, 3, 5, etc.

Next
‘
For i = 10 To 1 Step -1
‘ contará desde 10 hasta 1
‘ la variable i tomará los valores 10, 9, 8, etc.
Next
‘
For i = 100 To 1 Step -10
‘ contará desde 100 hasta 1, (realmente hasta 10)
‘ la variable i tomará los valores 100, 90, 80, etc.
Next
‘
For i = 10 To 1
‘ este bucle no se repetirá ninguna vez
Next
‘
For i = 1 To 20 Step 50
‘Esto se repite solo una vez
Next

Ejemplos con FOR…NEXT

‘Manejo de Sentencias repetitivas - Sentencia FOR

‘Imprimir del 1 al 20, los numeros pares
Dim num As Integer
For num = 0 To 20 Step 2
[Link](“El numero es {0}”, num)
Next
[Link]()

Impresión de los 10 primeros números en forma ascendente

[Link](“**************************************”)
Dim valor As Integer
For valor = 1 To 10
[Link](“El numero es {0}”, valor)
Next
[Link]()
[Link](“**************************************”)

Ejemplo de Hallar un factorial de los 7 Primeros Números

‘Hallar el Factorial de los 7 primeros numeros

Dim num1, fac1, resul1 As Integer
For num1 = 1 To 7
resul1 = 1
For fac1 = 1 To num1
resul1 = resul1 * fac1
Next
[Link](“El Resultado factorial de {0} es {1}”, num1, resul1)
Next
[Link]()
92 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Sentencia For Each…Next

Una instrucción For Each…Next ejecuta un bloque de instrucciones para cada elemento de una
colección o una matriz.

Definición de colecciones
Una colección es un conjunto de objetos agrupados conjuntamente y a los que se hace referencia
como una unidad.

Las colecciones nos permiten fácilmente añadir, borrar y contar elementos. Utilizando un número de
índice o valores clave, podemos añadir elementos antes o después de otros elementos. Las colecciones
son similares a las matrices, pero proporcionan funcionalidades que las matrices no tienen, incluyendo
la facilidad de añadir, eliminar y manipular elementos, y más funcionalidades con objetos.

Podemos crear nuestras propias colecciones y añadirles nuestros propios elementos o elementos
existentes. Un elemento puede ser cualquier tipo de datos, incluyendo objetos o estructuras, e incluso
otros objetos de la colección.

El .NET Framework también proporciona numerosas colecciones predefinidas. Algunos ejemplos de

colecciones del .NET Framework predefinidas son:

Cuando añadimos elementos a un ListBox, utilizamos la colección Items. Cada elemento que añadimos
es un miembro de la colección.

Cada formulario tiene una colección de controles Controls que representa todos los controles de ese
formulario. Podemos obtener una referencia a un control de la colección utilizando su índice, y recorrer
los miembros de la colección utilizando las instrucciones For Each…Next.

Cada hoja de cálculo de Microsoft Excel forma parte de la colección Worksheet de Excel. Esto significa
que podemos escribir código para recorrer hojas de cálculo de Excel y reunir datos en una nueva hoja
de cálculo.

Sintaxis
La sintaxis para la instrucción For Each…Next es la siguiente:

For Each elementvariable In collection

‘ Statement block to be executed for each value
‘ of elementvariable
Next [elementvariable]

Ejemplo de For Each

Dim s As String
‘
For Each s In “Hola Mundo”
[Link](s)
Next
[Link]()
 Capítulo 3: Estructuras de Control - Condicionales 93

Ejemplo de la Instrucción For Each

En este ejemplo vamos a crear un proceso que permita contabilizar cuantos controles existen, en el
Formulario, para esto diseñamos el siguiente formulario:

En el comboxBox, en la propiedad Items, escribimos lo siguiente:

Propiedad

Text Seleccione un Proceso

Items Modifica los Controles del GroupBox basados en tipo Conteo de
controles del Form y del GroupBox

Ahora vamos a adicionar el siguiente código:

Private Sub ComboBox1_SelectedIndexChanged(ByVal sender As [Link], ByVal

e As [Link]) Handles [Link]
‘Evento que se ejecuta cuando se cambia de items en el comboBox
Select Case [Link] ‘El dato seleccionado
Case Is = [Link](0) ‘Modifica los Controles del GroupBox basados
en tipo
Dim TotalControles As Integer = [Link] ‘Cantidad
controles del GroupBox
Dim contador As Integer
For contador = 0 To TotalControles - 1
If TypeOf ([Link](contador)) Is TextBox Then
[Link](contador).ForeColor = [Link]
Else
[Link](contador).ForeColor = [Link]
End If
Next
Case Is = [Link](1) ‘ si es el dato “Conteo de controles del
Form y del GroupBox”
Dim totalcontroles As Integer = [Link] ‘Total de controles
del Formulario
Dim ControlesGrupo As Integer = [Link] ‘Total de
controles del Group Box
MsgBox(“Los controles del Formulario son “ & totalcontroles)
MsgBox(“Los controles del Grupo son “ & ControlesGrupo)
End Select
End Sub
94 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Estructuras de Repetición por Condición.

Sentencia WHILE
La sentencia while permite ejecutar repetidamente un bloque mientras la condición sea verdadera.
Una sentencia while es un ejemplo de lo que denominamos declaración repetitiva.

Formato
While [Condición hasta que sea Verdad]
Condición → Exit Do
End While

Algunos ejemplos de hallar el factorial de los 7 primeros números

‘Hallar el factorial de un numero, menor a 6

Dim nro, fact, result As Integer
fact = 1 : result = 1
[Link](“ingrese Numero: “) : nro = [Link]
While (nro >= fact)
result = result * fact : fact = fact + 1
End While
[Link](“El Resultado factorial de {0} es {1}”, nro, result)
[Link]()

‘Manejo de Sentencias repetitivas - Sentencia While

‘Imprimir del 1 al 20, los numeros pares
Dim num As Integer
num = 0
While (num <= 20)
[Link](“El numero es {0}”, num)
num = num + 2
End While
[Link]()

‘Hallar el Factorial de los 7 primeros numeros

Dim num1, fac1, resul1 As Integer
num1 = 1
While (num1 <= 7)
fac1 = 1 : resul1 = 1
While (fac1 <= num1)
resul1 = resul1 * fac1 : fac1 = fac1 + 1
End While
[Link](“El Resultado factorial de {0} es {1}”, num1, resul1)
num1 = num1 + 1
End While

Para poder abandonar un bucle (esto veremos que es ampliable a otros temas) hay que usar la
instrucción Exit seguida del tipo de bucle que queremos abandonar:

Exit For
Exit While
Exit Do

Esto es útil si necesitamos abandonar el bucle por medio de una condición, normalmente se utiliza con
un If / Then.
 Capítulo 3: Estructuras de Control - Condicionales 95

Ejemplo – Trabajando con Sentencia Repetitivas

Vamos a realizar el siguiente formulario, trabajando con el Listbox, vamos a realizar un propuesta de
crédito, desarrollando un plan de pagos, el formulario tiene el siguiente formato:

Ahora veamos el siguiente código que tiene el formulario:

Private Sub btnGenerar_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
‘llama a una funcion que se llama calcula, tiene 3 para metros
calcula(Val([Link]), Val([Link]), Val([Link]))
End Sub

Ahora generamos la función calcula

Sub calcula(ByVal Monto As Single, ByVal Tasa As Single, ByVal Mes As Integer)
Dim Fecha As Date
Dim Saldo, Capital, Interes, Cuota As Single
Dim M As Integer
Saldo = Monto : Capital = Monto / Mes
For M = 1 To Mes
Fecha = DateAdd([Link], M, Now())
Interes = Saldo * Tasa / 100
Cuota = Capital + Interes
[Link](Format(Fecha, “d”))
[Link](Format(Saldo, “##,##0.0”))
[Link](Format(Capital, “##,##0.0”))
[Link](Format(Interes, “##,##0.0”))
[Link](Format(Cuota, “##,##0.0”))
Saldo = Saldo - Capital
Next
End Sub
96 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

El resultado del formulario seria de la siguiente manera

Ahora este mismo ejemplo desarrollemoslo con la sentencia repetitiva While…es sencillo.

Ejercicio – Ejemplo Utilizando Varios controles

Bueno vamos a Crear el siguiente formulario, con el nombre frmAlumnos, el cual va tener diferentes
procesos y controles, este tiene el siguiente diseño:
 Capítulo 3: Estructuras de Control - Condicionales 97

Agregar un modulo con el nombre modAlumnos, desde el explorador de soluciones seleccionar el

proyecto, dar el Click derecho y seleccionar agregar un nuevo elemento.

Dentro del módulo crearemos una estructura que representará la ficha de un alumno.

Module modAlumnos
Public Structure FichaAlumno
Public Nombres as String
Public Curso as String
Public Area as String
Public Seccion as String
Public tipoAlumno as Integer
End Structure
Enum TipoAlumno
Letras =1
Ciencias = 2
Ingenieria = 3
End Enum

Crear una variable en un ámbito visible, que represente la estructura:

Dentro del formulario, en el evento Load escribimos lo siguiente:

Private Sub frmAlumnos_Load(Byval sender as Object, e as EventArgs)

With stFicha
.Nombres =””
.Curso=””
.Area=””
.Seccion = “”
.TipoAlumno=0
End With
[Link]=””
[Link] = False
[Link] = False
End Sub
98 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

En el botón Evaluar colocamos lo siguiente:

Private Sub btnEvaluar_Click(Byval sender as Object, e as EventArgs)

[Link] = [Link]
[Link] = [Link]
[Link] = [Link]
[Link] = [Link]
[Link] = true
End Sub

En el botón calcular, colocar lo siguiente:

Private Sub btnCalcular_Click(Byval sender as Object, e as EventArgs)

dim n1 as integer = cInt([Link])
dim n2 as integer = cInt([Link])
dim n3 as integer = cInt([Link])
dim n4 as integer = cInt([Link])
‘Para obtener el promedio
dim nt as double
‘calculo de promedio
nt = (3*n1 +n2 + n3 * 2*n4) / 7
[Link] = nt

‘Calculo del Promedio procentual por tipo de alumno

dim xvar as double
if [Link] = [Link] then
xVar = 0.15
ElseIf [Link] = [Link] Then
xVar = 0.12
ElseIf [Link] = [Link] Then
xvar = 0.2
end if
NT * = xVar +1
[Link] = NT
[Link] = [Link] + “, su promedio fue: “ + cstr(Nt)
[Link] = true

end sub

FUNCIONES DE CONVERSIÓN EN VISUAL BASIC

Podemos utilizar funciones de conversión para forzar el resultado de una operación a un tipo de datos
particular en lugar del tipo de datos por defecto. Por ejemplo, podemos convertir un valor de tipo
cadena a un valor entero. Existen conversiones de tipo implícitas y de explicitas, las de tipos implícitas
son aquellas que el compilador asume a que tipo de dato se desea convertir, por ejemplo:

Dim res as string

Dim n1 as string=10, n2 as string =20
Res = n1 + n2 ‘Esta almacenando el valor de una suma de enteros a una variable string

Las variables de tipo explicitas, utilizan las funciones de conversión de tipo de dato, es decir que se les
dice de que tipo de dato se van a convertir, por ejemplo

Dim res as string

Dim n1 as string=10, n2 as string =20
Res =cstr(n1 + n2) ‘se ha convertido el resultado de la operación aritmética en
string
 Capítulo 3: Estructuras de Control - Condicionales 99

Definición
Las funciones de conversión permiten convertir explícitamente un valor de un tipo de datos a otro.

EJEMPLOS DE FUNCIONES DE CONVERSIÓN

Visual Basic ofrece una amplia lista de funciones de conversión. El código siguiente muestra cómo
utilizar varias funciones de conversión:

Private Sub Button1_Click(...)

‘usando una conversión string de un tipo entero
Dim myVariable As Integer
myVariable = 6541
[Link](myVariable)
[Link](CStr(myVariable) & “1”)
End Sub

Private Sub Button2_Click(...)

‘usando una conversión entero de un tipo double
Dim myVariable As Double
myVariable = 1567.9894
[Link](myVariable)
[Link](CInt(myVariable)) ‘lo convertimos a entero
End Sub

Private Sub Button3_Click(...)

‘usando una conversion fecha de un tipo string
Dim myVariable As String
myVariable = “February 12, 1992”
[Link](myVariable)
[Link](CDate(myVariable)) ‘lo convertimos a dato tipo fecha
End Sub
100 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ejemplo de la función CBool

Este ejemplo utiliza la función CBool para convertir expresiones en valores Boolean. Si una expresión
se evalúa a un valor distinto de cero, CBool devuelve True; en caso contrario, devuelve False.

Dim A, B, C As Integer
Dim Check As Boolean
A = 5
B = 5
Check = CBool(A = B) ‘ Check is set to True.
‘ ...
C = 0
Check = CBool(C) ‘ Check is set to False.

Ejemplo de la función CByte

Este ejemplo utiliza la función CByte para convertir expresiones en valores Byte.

Dim MyDouble As Double

Dim MyByte As Byte
MyDouble = 125.5678
MyByte = CByte(MyDouble) ‘ MyByte is set to 126.

Ejemplo de la función CChar

En este ejemplo, la función CChar convierte el primer carácter de una expresión String en un tipo Char.

Dim MyString As String

Dim MyChar As Char
MyString = “BCD”
MyChar = CChar(MyString) ‘ MyChar is set to “B”.

El argumento de entrada para CChar debe ser el tipo de datos String. No puede utilizar CChar para
convertir un número en un carácter, porque CChar no acepta un tipo de datos numéricos. Este ejemplo
obtiene un número que representa un punto de código (código de carácter) y lo convierte en el carácter
correspondiente. Utiliza InputBox para obtener la cadena de dígitos, CInt para convertir la cadena en el
tipo Integer y ChrW para convertir el número en el tipo Char.

Dim MyDigits As String ‘ Input string of digits to be converted.

Dim CodePoint As Integer ‘ Number to be represented as a character.
Dim MyChar As Char
MyDigits = InputBox(“Enter code point of character:”)
CodePoint = CInt(MyDigits) ‘ Convert entire string to Integer.
MyChar = ChrW(CodePoint) ‘ MyChar is set to Char value of code point.

Ejemplo de la función CDate

Este ejemplo utiliza la función CDate para convertir cadenas en valores Date. En general, no se
recomienda especificar las fechas y horas como cadenas en el código, tal y como se puede ver en este
ejemplo. Utilice literales de fecha y hora, por ejemplo #Feb 12, 1969# y #[Link] p.m.#.

Dim MyDateString, MyTimeString As String

Dim MyDate, MyTime As Date
MyDateString = “February 12, 1969”
MyTimeString = “[Link] PM”
‘ ...
MyDate = CDate(MyDateString) ‘ Convert to Date data type.
MyTime = CDate(MyTimeString) ‘ Convert to Date data type.
 Capítulo 3: Estructuras de Control - Condicionales 101

Ejemplo de la función CDbl

Este ejemplo utiliza la función CDbl para convertir expresiones en valores Double.

Dim MyDec As Decimal

Dim MyDouble As Double
MyDec = 234.456784D ‘ Literal type character D makes MyDec a Decimal.
MyDouble = CDbl(MyDec * 8.2D * 0.01D) ‘ Convert result to a Double.

Ejemplo de la función CDec

Este ejemplo utiliza la función CDec para convertir un valor numérico en Decimal.

Dim MyDouble As Double

Dim MyDecimal As Decimal
MyDouble = 10000000.0587
MyDecimal = CDec(MyDouble) ‘ Convert to Decimal.

Ejemplo de la función CInt

Este ejemplo utiliza la función CInt para convertir un valor en Integer.

Dim MyDouble As Double

Dim MyInt As Integer
MyDouble = 2345.5678
MyInt = CInt(MyDouble) ‘ MyInt is set to 2346.

Ejemplo de la función CLng

Este ejemplo utiliza la función CLng para convertir valores en Long.

Dim MyDbl1, MyDbl2 As Double

Dim MyLong1, MyLong2 As Long
MyDbl1 = 25427.45
MyDbl2 = 25427.55
MyLong1 = CLng(MyDbl1) ‘ MyLong1 contains 25427.
MyLong2 = CLng(MyDbl2) ‘ MyLong2 contains 25428.

Ejemplo de la función CObj

Este ejemplo utiliza la función CObj para convertir un valor numérico en Object. La variable Object en
sí contiene sólo un puntero de cuatro bytes, que señala al valor Double que tiene asignado.

Dim MyDouble As Double

Dim MyObject As Object
MyDouble = 2.7182818284
MyObject = CObj(MyDouble) ‘ Double value is pointed to by MyObject.

Ejemplo de la función CShort

Este ejemplo utiliza la función CShort para convertir un valor numérico en Short.

Dim MyByte as Byte

Dim MyShort as Short
MyByte = 100
MyShort = CShort(MyByte) ‘ Convert to Short.
102 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ejemplo de la función CSng

Este ejemplo utiliza la función CSng para convertir valores en Single.

Dim MyDouble1, MyDouble2 As Double

Dim MySingle1, MySingle2 As Single
MyDouble1 = 75.3421105
MyDouble2 = 75.3421567
MySingle1 = CSng(MyDouble1) ‘ MySingle1 is set to 75.34211.
MySingle2 = CSng(MyDouble2) ‘ MySingle2 is set to 75.34216.

Ejemplo de la función CStr

Este ejemplo utiliza la función CStr para convertir un valor numérico en String.

Dim MyDouble As Double

Dim MyString As String
MyDouble = 437.324
MyString = CStr(MyDouble) ‘ MyString is set to “437.324”.
Este ejemplo utiliza la función CStr para convertir valores Date en valores String.
Dim MyDate As Date
Dim MyString As String
‘ ...
MyDate = #February 12, 1969 [Link]# ‘ INVALID format.
‘ Date literals must be in the format #m/d/yyyy# or they are invalid.
‘ ...
MyDate = #2/12/69 [Link]# ‘ Time is midnight.
‘ The neutral time value of [Link] is suppressed in the conversion.
MyString = CStr(MyDate) ‘ MyString is set to “2/12/1969”.
‘ ...
MyDate = #2/12/69 [Link]# ‘ Time is one second past midnight.
‘ The time component becomes part of the converted value.
MyString = CStr(MyDate) ‘ MyString is set to “2/12/1969 [Link] AM”.

CStr siempre procesa un valor Date en el formato corto estándar de la configuración regional actual,
por ejemplo, “15/6/2003 [Link] p.m.”.

FUNCIONES DE CONVERSIÓN
Asc, AscW - Devuelve un valor Integer que representa el código de carácter que le corresponde a un
carácter.

Asc devuelve el punto de código o código de carácter para el carácter de entrada. Pueden ser valores
comprendidos entre 0 y 255 para el juego de caracteres de un solo byte (SBCS) y valores comprendidos
entre –32768 y 32767 para el juego de caracteres de doble byte (DBCS).

AscW devuelve el punto de código Unicode para el carácter de entrada. Puede estar comprendido
entre 0 y 65535. El valor devuelto es independiente de la configuración de referencia cultural y página
de códigos del subproceso actual.
 Capítulo 3: Estructuras de Control - Condicionales 103

Ejemplo: Este ejemplo utiliza la función Asc para devolver los códigos de carácter Integer
correspondientes a la primera letra de cada cadena.
Dim iA As Integer
iA = Asc(“A”) ‘ iA vale 65.
iA = Asc(“a”) ‘ iA vale 97.
iA = Asc(“Apple”) ‘ iA vale 65.

FUNCION MESSAGEBOX
Muestra un cuadro de mensaje con el texto, el título, los botones, el icono, el botón predeterminado,
las opciones y el botón Ayuda especificados

Formato

[Link](text, caption, buttons, icon, defaultButton, options)

Definición de parámetros

text
Texto que se va a mostrar en el cuadro de mensaje.

caption
Texto que se va a mostrar en la barra de título del cuadro de mensaje.

buttons
Uno de los valores MessageBoxButtons que especifica qué botones se mostrarán en el cuadro de
mensaje.

icon
Uno de los valores de MessageBoxIcon que especifica qué icono se mostrará en el cuadro de mensaje.

defaultButton
Uno de los valores de MessageBoxDefaultButton que especifica cuál es el botón predeterminado del
cuadro de mensaje.

options
Uno de los valores de MessageBoxOptions que especifica las opciones de pantalla y asociación que se
utilizarán para el cuadro de mensaje. Puede transferir 0 si desea utilizar los valores predeterminados.

Valor devuelto
Uno de los valores de DialogResult.

Un cuadro de mensaje es un cuadro de diálogo modal, lo que significa que no se pueden

proporcionar datos, ni mediante el teclado ni mediante el mouse (ratón), salvo en los objetos
del formulario modal. El programa debe ocultar o cerrar un formulario modal (normalmente,
en respuesta a una acción del usuario) antes de admitir la entrada de datos en otro formulario.
104 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ejemplo de Cálculo de Promedio

Este ejercicio permitirá calcular un promedio de notas de N notas ingresadas, se hallara el promedio de
todas las notas ingresadas, también hallara la máxima nota y la minima nota. El diseño de formulario
es el siguiente:

Controles Propiedades Valor

Label Text Calculo de Promedio Alumno
Label Text Ing. Cantidad de Notas:
Label Text Nro. Nota:
Label Text Nota:
Label Text Max. Nota:
Label Text Min. Nota:
label Text Promedio:
Button (name) btnEjecutar
Text Ejecutar
Button (name) btnAdicionar
Text Adicionar
Button (name) btnNuevo
Text Nuevo
Button (name) btnCancelar
Text Cancelar
Textbox (name) txtCantNotas
Textbox (name) txtNroNota
Textbox (name) txtNota
Textbox (name) txtMaximo
Textbox (name) txtMinimo
Textbox (name) txtPromedio
Listbox (name) lstNotas
 Capítulo 3: Estructuras de Control - Condicionales 105

Ahora empecemos a codificar, empecemos declarando algunas variables globales al objeto

Dim cantidad As Integer = 0
Dim maximo As Integer = 0
Dim minimo As Integer = 1000
Dim suma As Integer = 0
Private Sub btnEjecutar_Click(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
If [Link] <> “” Then
[Link] = “1”
cantidad = CInt([Link])
[Link] = False : [Link] = False
[Link] = False : [Link]()
End If
End Sub

Generemos el código para el botón Adicionar

Private Sub btnAdicionar_Click(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
If [Link] <> “” Then
If CInt([Link]) >= 1 And CInt([Link]) <= 20 Then
[Link]([Link])
If maximo < CInt([Link]) Then
maximo = CInt([Link])
End If
If minimo > CInt([Link]) Then
minimo = CInt([Link])
End If
suma = suma + CInt([Link])
[Link] = maximo ‘Asigna el maximo al control
[Link] = minimo ‘Asigna el minimo al control
[Link] = suma / CInt([Link]) ‘halla el promedio
If CInt([Link]) < cantidad Then
[Link] = CInt([Link]) + 1
[Link]() : [Link]()
Else
[Link] = False
[Link] = False
End If
Else
[Link](“Fuera de Rango la Nota”, “Error”)
[Link]() : [Link]()
End If
Else
[Link](“Falta Ingresar la Nota...!!!!!”)
[Link]()
End If
End Sub

Codificacion de boton Nuevo

Private Sub btnNuevo_Click(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
[Link]()
[Link] = True
[Link]()
[Link] = True
[Link]()
[Link] = True
[Link]()
[Link]()
[Link]()
[Link]()
[Link]()
End Sub

Codifiquemos el boton Cerrar

Private Sub btnCerrar_Click(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
Close()
End Sub
106 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ejemplo de manejo de ListBox

En este ejemplo vamos a ingresar nombres y cuando demos clic en el botón ingresar vamos a ingresarlo
en el listbox de postulante después podemos mover la información de un listbox a otros. Vamos a
diseñar el siguiente formulario:

Propiedades de los Controles

Control Propiedad Valor

Label Text Manejo de Controles Listbox
Dock Top
Label Text Ing. Nombre
Label Text Postulante
Label Text Ingresante
Textbox (name) txtNombre
Button (name) btnIngresar
Text &Ingresar
Button (name) btnCerrar
Text &Cerrar
Button (name) btn1d
Text >
Button (name) btnTd
Text >>
Button (name) btn1i
Text <
Button (name) btnTi
Text <<
Listbox (name) lstPostulante
Listbox (name) lstIngresantes
 Capítulo 3: Estructuras de Control - Condicionales 107

Bueno ahora empecemos a codificar este formulario

Empecemos con el botón Ingresar

Private Sub btnIngresar_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
If [Link] <> “” Then
[Link]([Link])
Else
MsgBox(“No se Ingreso Producto...!!!!”)
End If
[Link]()
[Link]()
End Sub

Ahora realicemos el proceso para el envío de la información de Postulante a Ingresantes, empecemos

con el botón que envía solo 1a la derecha

Private Sub btn1d_Click(ByVal sender As [Link], ByVal e As [Link])

Handles [Link]
If [Link] <> -1 Then
[Link]([Link])
[Link]([Link])
Else
MsgBox(“No ha Seleccionado Nada....!!!!”)
End If
End Sub

Y finalmente el que envía todos los ítems de postulante a Ingresantes

Private Sub btnTd_Click(ByVal sender As [Link], ByVal e As [Link])

Handles [Link]
Dim fila As Integer
For fila = 0 To [Link] - 1
[Link]([Link](fila))
Next
[Link]()
End Sub

Que tal… sencillo, bueno ahora para que puedan practicar, desarrollen el regreso de los datos es decir
de ingresantes a postulante… es sencillo… SUERTE!!!!
108 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ejemplo de Proceso de Compra y Venta de Dólares

Vamos a desarrollar un formulario que permita poder imitar el proceso de compra y venta de dólares,
inicializar el día con un monto en soles y dólares, y según eso realizar las transacciones de compra y
venta, para esto diseñamos el siguiente formulario:

Ahora veamos las propiedades de los controles insertados:

Control Propiedad Valor

Label Text Compra / Venta Dolares
Label Text Mto. Inicial S/. :
Label Text Mto. Inicial $ :
Label Text T.C.C:
Label Text T.C.V:
Label Text S/.
Label Text $
Label Text Mto. Actual S/. :
Label Text Mto Actual $ :
Textbox (name) txtMtoInicialSol
Textbox (name) txtMtoInicialSol
Textbox (name) Txt_tcc
Textbox (name) Txt_tcv
Textbox (name) txtCompraSol
Textbox (name) txtCompraDol
Textbox (name) txtVentaSol
Textbox (name) txtVentaDol
Textbox (name) TtxtMtoActualSol
Textbox (name) TtxtMtoActualDol
Button (name) btnInicioDia
Text Inicio Dia
Groupbox Text Proceso de Compra / Venta de Dólares
Groupbox Text Datos de Inicio de Día
 Capítulo 3: Estructuras de Control - Condicionales 109

Ahora Empezaremos a codificar los eventos

Private Sub habilita_det(ByVal tipo As Boolean, ByVal tipo_cab As Boolean)

‘Detalle
rb_compra.Enabled = tipo : [Link] = tipo
[Link] = tipo : rb_venta.Enabled = tipo
[Link] = tipo : [Link] = tipo
[Link] = tipo
‘[Link] = tipo : [Link] = tipo
‘Cabecera
[Link] = tipo_cab : [Link] = tipo_cab
txt_tcc.Enabled = tipo_cab : txt_tcv.Enabled = tipo_cab
[Link] = tipo_cab
End Sub

Private Sub Form9_Load(ByVal sender As [Link], ByVal e As [Link]) _

Handles [Link]
habilita_det(False, True)
End Sub

Private Sub btnInicioDia_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) _
Handles [Link]
If [Link] <> “” Then
If [Link] <> “” Then
If txt_tcc.Text <> “” Then
If txt_tcv.Text <> “” Then
habilita_det(True, False)
[Link] = [Link]
[Link] = [Link]
Else ‘Falte el tipo de venta
MsgBox(“Falta Ingresar el Tipo venta”) : txt_tcv.Focus()
End If
Else ‘Falte el tipo Compra
MsgBox(“Falta Ingresar el Tipo Compra”) : txt_tcc.Focus()
End If
Else ‘Falte el Monto Incial Dolares
MsgBox(“Falta Ingresar el Mtop Inicial Dolares”) : txtMtoInicialDol.
Focus()
End If
Else ‘Falte el Monto Incial Soles
MsgBox(“Falta Ingresar el Mto Inicial Soles”) : [Link]()
End If
End Sub

Funciones de comprobación de tipos de datos

Si tenemos desactivada la comprobación de tipos con Option Strict, no se utiliza mucho esto, pero en
ciertas situaciones necesitamos comprobar si determinada variable o expresión contienen un valor
numérico, fecha, etc., el lenguaje nos proporciona para ello, algunas funciones con las que podremos
comprobar el tipo de dato, para evitar posibles errores son:
110 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

IsNumeric(). Esta función devuelve un valor lógico indicando si la expresión que pasamos como
parámetro contiene un número o una cadena que pueda ser convertida a número.

Public Sub Main()

Dim Valor As Object
Dim Total As Integer
[Link](“Introducir un número”)
Valor = [Link]()
If IsNumeric(Valor) Then
Total = Valor + 100
[Link](“Resultado: {0}”, Total)
Else
[Link](“El valor introducido no es numérico”)
End If
[Link]()
End Sub

IsDate(). Esta función devuelve un valor lógico indicando si la expresión que pasamos como parámetro
contiene una fecha o una cadena que pueda ser convertida a fecha.

Public Sub Main()

Dim Valor As Object
Dim UnaFecha As Date
[Link](“Introducir una fecha”)
Valor = [Link]()
If IsDate(Valor) Then
UnaFecha = Valor
[Link](“La fecha es: {0}”, UnaFecha)
Else
[Link](“El valor introducido no es una fecha”)
End If
[Link]()
End Sub

IsArray( ). Esta función devuelve un valor lógico indicando si la expresión que pasamos como parámetro
contiene un array.

Public Sub Main()

Dim Colores() As String = {“Verde”, “Azul”, “Rojo”}
Verificar(Colores)
Verificar(“prueba”)
[Link]()
End Sub
Public Sub Verificar(ByVal ValorPasado As Object) ‘ verifica si el parámetro contiene
un array
If IsArray(ValorPasado) Then
[Link](“El parámetro pasado es un array”)
Else
[Link](“El parámetro pasado no es un array”)
End If
End Sub
 Capítulo 3: Estructuras de Control - Condicionales 111

FUNCIONES de Cadena de Caracteres

Len(Cadena). Devuelve un número con la longitud de la cadena pasada como parámetro.

Dim Longitud As Integer

Longitud = Len(“comprobar cuantos caracteres hay”)
[Link](“La cadena tiene {0} caracteres”, Longitud) ‘ 32

Space(Número). Devuelve una cadena de espacios en blanco, de una longitud igual al número pasado
como parámetro.

Dim ConEspacios As String

ConEspacios = “Hola” & Space(7) & “a todos”
[Link](“La cadena con espacios tiene el valor:” & _
[Link] & ConEspacios) ‘ Hola a todos

InStr([Comienzo, ]CadenaBuscar, CadenaBuscada [, TipoComparación]). Busca dentro de

CadenaBuscar la cadena contenida en el parámetro CadenaBuscada. Opcionalmente podemos
establecer en Comienzo, la posición en la que comienza la búsqueda y el tipo de comparación (texto,
binaria) en el parámetro TipoComparación.

Dim CadBuscar As String

Dim CadBuscada As String
Dim PosComienzo As Integer
CadBuscar = “El castillo del bosque”
PosComienzo = InStr(CadBuscar, “tillo”)
[Link](“La posición de comienzo de la cadena encontrada es: {0}”, _
PosComienzo) ‘ 7

Left(Cadena, Longitud). Esta función extrae, comenzando por la parte izquierda de Cadena, una
subcadena de Longitud de caracteres.

Right(Cadena, Longitud). Esta función extrae, comenzando por la parte derecha de Cadena, una
subcadena de Longitud de caracteres. El Código fuente 191 muestra ejemplos de Left( ) y Right( ).

Dim CadIzquierda As String

Dim CadDerecha As String
CadIzquierda = Left(“Especial”, 3)
[Link](“Resultado de la función Left(): {0}”, CadIzquierda) ‘ Esp
CadDerecha = Right(“Especial”, 3)
[Link](“Resultado de la función Right(): {0}”, CadDerecha) ‘ ial

Mid(Cadena, Inicio [, Longitud]). Extrae de Cadena, comenzando en la posición Inicio, una subcadena.
Opcionalmente podemos utilizar el parámetro Longitud, para indicar el largo de la subcadena. En caso
de no utilizar este último parámetro, la subcadena se obtendrá hasta el final.

Dim MiCadena As String

Dim SubCadena As String
MiCadena = “El bosque encantado”
SubCadena = Mid(MiCadena, 6)
[Link](“Subcadena hasta el final: {0}”, SubCadena) ‘ sque
encantado
SubCadena = Mid(MiCadena, 6, 3)
[Link](“Subcadena de 3 caracteres: {0}”, SubCadena) ‘ squ
112 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Replace(Cadena,CadOrigen,CadNueva [,Inicio] [,Sustituciones] [,TipoComparación]).

Esta función toma la cadena situada en el primer parámetro y busca la cadena CadOrigen, sustituyendo
las ocurrencias encontradas por la cadena CadNueva. Opcionalmente, el parámetro Inicio especifica la
posición en la que comenzará la sustitución; el parámetro Sustituciones indica el número de sustituciones
a realizar; y TipoComparación indica como se realizarán las comparaciones (texto, binaria).

Dim MiCadena As String

Dim CadSustituida As String
MiCadena = “Este coche es especial”
CadSustituida = Replace(MiCadena, “es”, “xx”)
‘ resultado: Este coche xx xxpecial
[Link](“Resultado del reemplazo en la cadena: {0}”, CadSustituida)
‘ en el anterior ejemplo los dos primeros caracteres
‘ no se sustituyen porque no se ha especificado el tipo
‘ de comparación, que a continuación sí indicaremos
CadSustituida = Replace(MiCadena, “es”, “xx”, , , [Link])
‘ resultado: xxte coche xx xxpecial
‘ ahora sí se han sustituido todas las ocurrencias de “es”
[Link](“Resultado del reemplazo en la cadena: {0}”, CadSustituida)

LTrim(Cadena), RTrim(Cadena), Trim(Cadena). Estas funciones eliminan de una cadena, los espacios
en blanco a la izquierda en el caso de LTrim( ); los espacios en blanco a la derecha en el caso de RTrim();
o los espacios en blanco a ambos lados Trim( ).

Dim CadEspacios As String

Dim CadResultante As String
CadEspacios = “ Barco “
CadResultante = LTrim(CadEspacios) ‘ “Barco “
CadResultante = RTrim(CadEspacios) ‘ “ Barco”
CadResultante = Trim(CadEspacios) ‘ “Barco”

UCase(Cadena), LCase(Cadena). Estas funciones, convierten la cadena pasada como parámetro a

mayúsculas y minúsculas respectivamente.

Dim Cadena As String

Dim CadMay As String
Dim CadMin As String
Cadena = “Vamos a Convertir En Mayúsculas Y MinúscuLAS”
CadMay = UCase(Cadena)
CadMin = LCase(Cadena)
‘ “VAMOS A CONVERTIR EN MAYÚSCULAS Y MINÚSCULAS”
[Link](“Conversión a mayúsculas: {0}”, CadMay)
‘ “vamos a convertir en mayúsculas y minúsculas”
[Link](“Conversión a minúsculas: {0}”, CadMin)

FUNCIONES de Fecha y hora

Now( ). Devuelve un valor de tipo Date con la fecha y hora del sistema.

DateAdd(TipoIntervalo, ValorIntervalo, Fecha). Suma o resta a una fecha, un intervalo determinado

por el parámetro TipoIntervalo. El intervalo a utilizar pueden ser días, semanas, meses, etc. Para
determinar si se realiza una suma o resta, ValorIntervalo deberá ser positivo o negativo respectivamente.

DateDiff(TipoIntervalo, FechaPrimera, FechaSegunda). Calcula la diferencia existente entre dos

fechas. En función de TipoIntervalo, la diferencia calculada serán días, horas, meses, años, etc.
 Capítulo 3: Estructuras de Control - Condicionales 113

DatePart(TipoIntervalo, Fecha). Extrae la parte de una fecha indicada en TipoIntervalo. Podemos

obtener, el día, mes, año, día de la semana, etc.

Dim MiFecha As Date

Dim FechaPosterior As Date
Dim DiasDiferencia As Long
Dim ParteFecha As Integer
MiFecha = Now() ‘ #1/19/2002 [Link] PM#
FechaPosterior = DateAdd([Link], 2, MiFecha) ‘ #3/19/2002 [Link] PM#
DiasDiferencia = DateDiff([Link], MiFecha, FechaPosterior) ‘ 59
ParteFecha = DatePart([Link], MiFecha) ‘ 2002

Ejemplo de cómo Trabajar con Funciones de Fecha y Cadena

Vamos a desarrollar un ejemplo donde utilizaremos algunas de las funciones de fecha y de cadena,
crearemos el siguiente formulario:

Ahora empecemos a codificar de la siguiente manera:

En el textbox (TextBox1), donde ingresaremos la cadena, vamos a codificar el evento TextChanged:

Private Sub TextBox1_TextChanged(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Dim cadena As String = [Link]
[Link] = [Link]
[Link] = [Link]

[Link] = [Link](cadena, 2)
[Link] = [Link](cadena, 2)

[Link] = [Link]

[Link] = [Link]
[Link] = New [Link](“Verdana”, 14)
[Link] = cadena

End Sub
114 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ahora en el datetimepicker(DateTimePicker1), en el cual seleccionaremos la fecha, vamos a dar doble

clic, para codificar su evento ValueChanged(se ejecuta cuando se cambia de valor):

Private Sub DateTimePicker1_ValueChanged(ByVal sender As [Link], ByVal e As

[Link]) Handles [Link]
Dim fecha As Date = [Link]

[Link] = DatePart([Link], fecha)

[Link] = DatePart([Link], fecha)
[Link] = DatePart([Link], fecha)

[Link] = Format(fecha, “dddd”)

[Link] = Format(fecha, “MMMM”)
[Link] = Format(fecha, “hh:mm:ss tt”)

End Sub

Quedando de esta manera la ejecución del formulario:

 Capítulo 3: Estructuras de Control - Condicionales 115

FUNCIONES, SUB RUTINAS Y PROCEDIMIENTOS

Los procedimientos son las sentencias de código ejecutable de un programa. Las instrucciones de un
procedimiento están delimitadas por una instrucción de declaración y una instrucción End.

Es posible que encontremos los términos métodos, procedimientos y funciones de forma intercambiable
en varias referencias. Este módulo sigue la terminología de la documentación de Microsoft® Visual
Studio 2010.

Los procedimientos son las sentencias de código ejecutable de un programa. las instrucciones de un
procedimiento están delimitadas por una instrucción de declaración y una instrucción End.

Modificador de acceso Descripción

Public Ninguna restricción de acceso.
Friend Accesible desde el programa que contiene la declaración y
desde cualquier otro lugar del mismo ensamblado.
Private Accesible únicamente en el módulo que contiene la
declaración.

Se definen los siguientes tipos:

Procedimientos Sub: Los procedimientos Sub, realizan acciones pero no devuelven un valor al
procedimiento que realiza la llamada.

[Acceso] Sub [Nombre del Procedimiento] (Argumentos)

‘Function Statements
End Sub

Procedimientos Function: Los procedimientos Function, realizan acciones y pueden devolver un valor
al programa que realiza la llamada.

[Acceso] Function [Nombre del Procedimiento] (Argumentos) As DataType

‘Function Statements
Return DataType
End Sub

Argumentos en los Procedimientos: Los argumentos son datos pasados a procedimientos, podemos
dos tipos de argumentos: ByVal y ByRef.

ByVal: Declaración de un Parámetro por Valor.

ByRef: Declaración de un Parámetro del Valor por Referencia.

116 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

CREACIÓN DE PROCEDIMIENTOS SOBRE CARGADOS

La sobrecarga de funciones (tanto para funciones como para procedimientos Sub), es una característica
que nos permite tener una misma función con diferentes tipos de parámetros, ya sea en número o en
tipo.

Supongamos que queremos tener dos funciones (o más) que nos permitan hacer operaciones con
diferentes tipos de datos, y que, según el tipo de datos usado, el valor que devuelva sea de ese mismo
tipo.

Ejemplo de procedimientos sobre cargados:

Llamada a un Procedimiento o Función Sobre Cargado:

Cuando nosotros estamos trabajando con procedimientos sobrecargados al momento de invocarlo nos
muestra la sobrecarga que tiene las funciones o sub rutinas que hemos creado, como es el caso del
ejemplo siguiente:

También existen funciones o métodos que tiene Visual Basic que están sobrecargados, los cuales al
utilizarlo nos mostrara todas las sobrecargas que tiene:

Cómo utilizar argumentos opcionales en un procedimiento o función

Podemos especificar que el argumento de un procedimiento es opcional y no es necesario proporcionarlo
cuando el procedimiento es invocado. Esto ofrece flexibilidad cuando nuestro procedimiento es
invocado por otro procedimiento. El usuario puede decidir proporcionar o no un argumento.
 Capítulo 3: Estructuras de Control - Condicionales 117

Como Declarar un argumento opcional

Los argumentos opcionales están indicados por la palabra clave Optional en la definición del
procedimiento. Además, cuando declaramos un argumento opcional, se aplican las siguientes reglas:
• Debe especificarse un valor predeterminado para todos los argumentos opcionales.
• El valor predeterminado de un argumento opcional debe ser una expresión constante.
• Todos los argumentos que sigan a un argumento opcional en la definición del procedimiento
también deben ser opcionales.

El siguiente código muestra la sintaxis para declarar un argumento opcional:

Optional [ByVal|ByRef] nombreargumento As datatype = defaultvalue

Ejemplo de argumento opcional

El siguiente ejemplo muestra una declaración de procedimiento con un argumento opcional:

Function Add(ByVal value1 As Integer, ByVal value2 As Integer, Optional ByVal value3
As Integer = 0) As Integer
‘ El valor por defecto del argumento opcional es 0
……………………..
End Function

Ejemplo de argumento opcional incorrecto

El siguiente ejemplo contiene un error; recordemos que los argumentos que siguen a un argumento
opcional también deben ser opcionales.

Function Add(ByVal value1 As Integer, Optional ByVal value2 As Integer = 0, ByVal

value3 As Integer) As Integer
‘ La causa del error es que nunca después de un argumento opcional puede ir un
argumento normal
………….
End Function

Ejemplo de Trabajar con Subrutinas y Funciones

Se quiere realizar un ejercicio en el cual se pueda poner práctica lo que es la sobrecarga de subrutinas,
el manejo de argumentos por valor y por referencia y los argumentos opcionales
118 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Estos primeros procedimientos lo que hacen es el manejo de la sobrecarga de subrutinas

Private Sub proceso() ‘Proceso1

Dim n1, n2, res As Integer
n1 = CInt([Link]) : n2 = CInt([Link])
res = n1 + n2 : [Link] = CStr(res)
End Sub

Private Function fproceso() As String ‘Proceso1

Dim n1, n2, res As Integer
n1 = CInt([Link])
n2 = CInt([Link])
res = n1 + n2
Return CStr(res)
End Function

Private Sub proceso(ByVal n1 As Integer, ByVal n2 As Integer) ‘Proceso 2

Dim res As Integer
res = (n1 + n2) * 2 : [Link] = res
End Sub

Private Sub proceso(ByVal n1 As String, ByVal n2 As String) ‘Proceso 3

[Link] = CStr((CInt(n1) + CInt(n2)) * 100)
End Sub

La variable res en este ejemplo es de tipo referencial en este caso como se pasa por referencia el valor
se modifica al momento de regresar al lugar donde fue llamado.

Private Sub Argumento(ByVal n1 As Integer, ByVal n2 As Integer, ByRef res As Integer)

res = n1 + n2
End Sub

Ahora trabajemos con un argumento Opcional, en cual cuando se invoca no es necesario ponerlo

Private Sub Opera(ByVal n1 As Integer, ByVal n2 As Integer, Optional ByVal operador

As String = “+”)
Dim res As Integer
Select Case operador
Case “+” : res = n1 + n2
Case “-” : res = n1 - n2
Case “*” : res = n1 * n2
Case “/” : res = n1 / n2
End Select
[Link] = CStr(res)
End Sub

Desde este evento llamamos todas las subrutinas creadas

Private Sub btnProceso_Click(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
Dim n1, n2 As Integer
n1 = CInt([Link]) : n2 = CInt([Link])
If [Link] = “” Then
Opera(n1, n2)
Else
Opera(n1, n2, [Link])
End If
 Capítulo 3: Estructuras de Control - Condicionales 119

‘ [Link] = fproceso() ‘Funcion

‘Dim n1, n2, res As Integer
‘n1 = CInt([Link]) : n2 = CInt([Link])
‘res = 0
‘Argumento(n1, n2, res)
‘[Link] = CStr(res)
‘num1 = CInt([Link]) : num2 = CInt([Link])
‘If num1 Mod 2 = 0 Then
‘ proceso([Link], [Link])
‘Else
‘ proceso(num1, num2)
‘End If
End Sub

Ejemplo de Venta de Productos

Crear el siguiente formulario, con el nombre frmVenta, con el siguiente diseño:

Agregar un modulo con el nombre modVentas, desde el explorador de soluciones, dentro de el agregar
una región:
120 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Dentro de la región escribir lo siguiente (Declaración de un Enum y una matriz con su método para
llenar dicha matriz):

Crear un procedimiento que realice el descuento del producto seleccionado:

Crear una función que realiza la búsqueda del producto, y llame al procedimiento anterior para realizar
el descuento.
 Capítulo 3: Estructuras de Control - Condicionales 121

En el Load del Formulario, primero llenamos la matriz con los productos, luego realizamos el recorrido
por esta matriz, hasta llenar el Listbox de todos los productos.

En el botón btnItodos colocamos lo siguiente, para que todos los productos se desplacen hacia el
Listbox lstPedidos.

En el botón btnIUno colocamos lo siguiente, para que los productos seleccionados se desplacen hacia
el Listbox lstPedidos.

Crear los métodos para los botones btnRTodos y btnRUno.

Por último, en el botón Crear Listado, colocamos lo siguiente:

 4
Programación Avanzada
en Visual Studio 2010
 CAPÍTULO

4 Programación Avanzada
en Visual Studio 2010
Ejemplo - Arrastrando Datos sobre los controles
El siguiente ejemplo se desea mover información de un listbox hacia otro listbox, pero este
movimiento no lo vamos hacer utilizando ningún control (como en ejemplos de capítulos anteriores)
sino arrastrando la información de un control hacia otro control.

Para esto vamos a diseñar el siguiente formulario:

Propiedades de los controles

Control Propiedad Valor
Listbox Text Listbox1
AllowDrop True
Listbox Text Listbox2
AllowDrop True

Lo primero que vamos hacer es trabajar para que se pueda realizar el arrastre los ítems desde el
listbox1 al listbox2, para eso codificamos en el evento MouseDown del listbox1

Private Sub ListBox1_MouseDown(ByVal sender As Object, ByVal e As [Link].

[Link]) Handles [Link]
‘declartar variable con efectos de la operacion Drag & Drop
Dim Operaciones As DragDropEffects
‘Si el Boton Pulsado del mouse es el izquierdo
If [Link] = [Link] Then
Operaciones = [Link]( _
[Link]([Link]), [Link] Or
[Link])
End If
‘Si el efecto es mover
If Operaciones = [Link] Then
[Link]([Link])
End If
End Sub
126 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ahora codificamos en el listbox2, esto se realizara para poder producir el efecto de Drag & Drop

Private Sub ListBox2_DragDrop(ByVal sender As Object, ByVal e As [Link].

[Link]) _
Handles [Link]
[Link]([Link]([Link]))
End Sub

Ahora codificaremos el siguiente evento del listbox2:

Private Sub ListBox2_DragEnter(ByVal sender As Object, ByVal e As [Link].

[Link]) _
Handles [Link]
‘Si esta presionada la tecla control
If [Link] = 9 Then
[Link] = [Link]
Else
[Link] = [Link]
End If
End Sub

Bueno ahora como trabajo para ud. realicen el arrastre desde el listbox2 al listbox1, es muy sencillo
tomen como ejemplo el script lo que hemos desarrollado en este ejemplo.

Ejemplo - Misceláneas en Visual Basic 10.0

En este ejemplo vamos realizar algunos procesos que normalmente son necesarios en el trabajo diario
de un desarrollador, por ejemplo trabajar con ENTER entre los controles, validar que solo acepte
números un control, detectar un IP, etc.

Para empezar con este ejemplo desarrollaremos el siguiente formulario:

 Capítulo 4: Programación Avanzada en Visual Studio 2010 127

Ahora veamos las propiedades de los controles que hemos adicionado en el formulario:

Control Propiedad Valor

Label Text Miscelaneas de Visual Basic
Label Text Validar Nro :
Label Text Campo 1:
Label Text Campo 2:
Label Text Ingrese Fechas Nac.:
Label Text Edad
Textbox (name) Textbox1
Textbox (name) Textbox2
Textbox (name) Textbox3
Textbox (name) Textbox4
Textbox (name) Textbox5
Textbox (name) Textbox6
Textbox (name) Textbox7
Textbox (name) Textbox8
Textbox (name) Textbox9
Button (name) Button1
Text Calculadora Ejecutable
Button (name) Button2
Text Generar Archivo TXT
Button (name) Button3
Text Conseguir Nro de IP
Button (name) Button4
Text Usuario Actual

Primero se debe crear un Modulo que se llame Proceso, en cual vamos a desarrollar las funciones que
utilizaremos en el programa principal

Module Procesos
‘Validacion de los caracteres que solo son enteros
Function Numeros(ByVal Keyascii As Short) As Short
If InStr(“1234567890”, Chr(Keyascii)) = 0 Then
Numeros = 0
Else
Numeros = Keyascii
End If
Select Case Keyascii
Case 8
Numeros = Keyascii
Case 13
Numeros = Keyascii
End Select
128 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

End Function
‘Validacion pàra Obtener la edad de una persona
Public Function Edad(ByVal Fechanac As DateTime) As Double
Dim dblEdad As Double = [Link](Fechanac).TotalDays / 365.25
Return dblEdad
End Function
Function GetUserName() As String
If TypeOf [Link] Is [Link]
Then
Dim parts() As String = Split([Link], “\”)
Dim username As String = parts(1)
Return username
Else
Return [Link]
End If
End Function

End Module

Ahora trabajando en el formulario, validar que los datos ingresados sobre la caja de texto sean de tipo
numéricos

Private Sub TextBox1_KeyPress(ByVal sender As Object, ByVal e As [Link].

[Link]) _
Handles [Link]
‘Validar de que todos los Datos sean Numericos
Dim KeyAscii As Short = CShort(Asc([Link]))
KeyAscii = CShort(Numeros(KeyAscii))
If KeyAscii = 0 Then
[Link] = True
End If
End Sub

Este proceso nos permite poder trabajar con la tecla enter para poder pasar de un control a otro
control

Private Sub TextBox2_KeyPress(ByVal sender As Object, ByVal e As [Link].

[Link]) _
Handles [Link]
‘Para poder trabajar con el Enter, del textbox2 pasar al textbox3
If [Link] = ChrW([Link]) Then
[Link] = True
[Link](“{TAB}”)
End If
End Sub

Como poder llamar a un ejecutable, en este caso se llamara a la Calculadora del Windows

Private Sub Button1_Click(ByVal sender As [Link], ByVal e As [Link])

Handles [Link]
‘Llamar a en Ejecutable
Dim proceso As New Process()
[Link] = “[Link]”
[Link] = “”
[Link]()
End Sub
 Capítulo 4: Programación Avanzada en Visual Studio 2010 129

Almacenar la información en un Archivo tipo Texto

Private Sub Button2_Click(ByVal sender As [Link], ByVal e As [Link]) _

Handles [Link]
‘ALamacenar la informacion en un Archivo tipo Texto
FileOpen(1, “c:\[Link]”, [Link])
Write(1, [Link])
FileClose(1)
End Sub

Para poder conseguir el Ip que tiene la maquina en estos momentos

Private Sub Button3_Click(ByVal sender As [Link], ByVal e As [Link]) _

Handles [Link]
‘esto Proceso para poder conseguir el IP
Dim ip As [Link]
Dim nombre_host As String = [Link]
Dim este_host As [Link] = [Link](nombre_host)
Dim direccion_ip As String = este_host.AddressList(0).ToString
[Link] = direccion_ip
End Sub

Calcular la edad ingresando como base una fecha(llamando a la función Edad que se encuentra en el
Modulo)

Private Sub Button4_Click(ByVal sender As [Link], ByVal e As [Link]) _

Handles [Link]
‘Se ingresa la edad y se calcula con la funcion Edad
Dim fecha As Date
fecha = CDate([Link])
[Link] = CStr(Edad(fecha))
End Sub

Obtener el usuario y la versión de la aplicación

Private Sub Button5_Click(ByVal sender As [Link], ByVal e As [Link]) _

Handles [Link]
‘Usuario
[Link] = GetUserName()
‘Version de tu aplicacion
[Link] = [Link]()
End Sub

MANEJO DE EXCEPCIONES
Las excepciones en Visual Basic 2010 las podemos controlar usando las instrucciones Try / Catch /
Finally., estas instrucciones realmente son bloques de instrucciones, al estilo de If / Else

Cuando queramos controlar una parte del código que puede producir un error lo incluimos dentro
del bloque Try, si se produce un error, éste lo podemos detectar en el bloque Catch, por último,
independientemente de que se produzca o no una excepción, podemos ejecutar el código que
incluyamos en el bloque Finally, para indicar el final del bloque de control de excepciones lo haremos
con End Try.
130 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ejemplo Inicial utilización el Try… Catch

Ahora realizaremos un ejemplo utilizando el TRY… CATCH, para esto desarrollaremos el siguiente
formulario:

Ahora veamos el código que desarrollaremos:

Private Sub BtnDividir_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Dim N1, N2, Res As Decimal
‘ Para producir una excepcion el tipo de dato debe ser DECIMAL
Try
N1 = [Link]
N2 = [Link]
Res = N1 / N2
[Link] = Res
Catch ex As Exception ‘En caso de que exista un Error
If [Link] <> 0 Then
[Link] = [Link]
End If
[Link]()
[Link]()
[Link]()
End Try
End Sub

El resultado sería el siguiente:

 Capítulo 4: Programación Avanzada en Visual Studio 2010 131

¿Qué es una excepción?

Una excepción es cualquier condición de error o comportamiento imprevisto que se produce durante
la ejecución de un programa y requiere la ejecución de código fuera del flujo de control normal. Las
excepciones pueden provocarse por un fallo de nuestro código o de código invocado, porque los
recursos del sistema operativo no estén disponibles, por condiciones imprevistas que encuentre el
CLR, etc. Una excepción se lanza (en otras palabras, se origina) desde el área del código donde se ha
producido un problema.

La clase Exception
En el .NET Framework, el entorno de ejecución crea un objeto que representa una excepción cuándo
ésta se produce. Las excepciones son objetos que heredan de la clase base Exception. El .NET Framework
define varias clases de excepciones. Estas clases proporcionan información sobre excepciones de un
modo significativo y nos permiten recuperar información sobre cualquier excepción que encontremos.
Esta información nos ayuda a depurar eficazmente nuestras aplicaciones.

La siguiente tabla describe algunas propiedades de la clase base Exception que nos ayudarán a
identificar la localización del código, tipo y causa de una excepción. Cualquier excepción que herede
de la clase base proporcionará estas propiedades.

Propiedad Descripción
StackTrace Ofrece una lista de los métodos invocados que conducen a la excepción,
ayudándonos a encontrar en qué parte del código se produce el error.
Message Devuelve un mensaje de texto que describe el error. Utilizar esta propiedad
para recuperar información acerca de porqué se ha lanzado una excepción.
Podemos cambiar el texto para que un mensaje críptico sea más fácil de
entender. Si no proporcionamos una cadena de texto para el mensaje de error,
se utilizará el valor predeterminado.
HelpLink Obtiene o establece un enlace a un archivo asociado de Ayuda.
Source Obtiene o establece una cadena que contiene el nombre del objeto que causa
el error o el nombre del ensamblado en el que se originó la excepción.

Cuando creamos una estructura de control de excepciones no estamos obligados a usar los tres
bloques, aunque el primero: Try si es necesario, ya que es el que le indica al compilador que tenemos
intención de controlar los errores que se produzcan. Por tanto podemos crear un “manejador” de
excepciones usando los tres bloques, usando Try y Catch o usando Try y Finally.

Try
En este bloque incluiremos el código en el que queremos comprobar los errores, el código a usar será
un código normal, es decir, no tenemos que hacer nada en especial, ya que en el momento que se
produzca el error se usará (si hay) el código del bloque Catch.

Catch
Si se produce una excepción, ésta la capturamos en un bloque Catch. En el bloque Catch podemos
indicar que tipo de excepción queremos capturar, para ello usaremos una variable de tipo Exception, la
cual pude ser del tipo de error específico que queremos controlar o de un tipo genérico.
132 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Finally
En este bloque podemos indicar las instrucciones que queremos que se ejecuten, se produzca o no una
excepción. De esta forma nos aseguramos de que siempre se ejecutará un código, por ejemplo para
liberar recursos, se haya producido un error o no.

Script de Validación de Errores

Dim x,y,r as Integer

Try
X=5
Y =6
R = x / y
[Link](“El resultado es :{0}”,r)
Catch ex as exception when y = 0
[Link](“No se puede Dividir por cero”)
Catch ex as Exception
[Link]([Link])
End Try

Utilizando la instrucción Try…Catch…Finally, podemos proteger bloques de código que potencialmente

podrían provocar errores.

El bloque Try incluye una expresión que podría generar una excepción. El bloque Try tiene una o más
instrucciones Catch asociadas, que filtran excepciones y las asocian con una determinada acción. Si se
produce la excepción, el entorno de ejecución detiene la ejecución normal e inicia la búsqueda de un
bloque Catch que pueda capturar la excepción, basándose en su tipo.

Si no se encuentra un bloque Catch apropiado en el procedimiento inmediato, el entorno de ejecución

continúa por la pila de llamadas buscando el procedimiento que originó la llamada.

Si no se encuentra un bloque Catch apropiado allí, el entorno de ejecución busca el procedimiento que
invocó el procedimiento de originó la llamada, y así sucesivamente, hasta encontrar un bloque Catch
apropiado.

Si se encuentra un bloque Catch, se considera que se ha capturado la excepción, y la ejecución se

reinicia, empezando con el cuerpo del bloque Catch.

Si no se encuentra ningún bloque Catch, aparecerá un mensaje de error y la aplicación se cerrará.

El bloque Finally es un bloque de código opcional, que si se incluye, siempre se ejecuta. En este bloque,
podemos definir acciones que deben realizarse con independencia de si se produce una excepción. Se
podrían incluir acciones como cerrar archivos o liberar objetos.

El bloque Finally se utiliza habitualmente para limpiar recursos utilizados en nuestro código cuando
un método falla.

El código de la sección Finally siempre se ejecuta al final, justo antes de que el bloque de gestión
de errores pierda el alcance. Si incluimos este bloque, se ejecuta después del bloque Try si no se
producen errores, o después de que el bloque Catch adecuado se haya procesado si se ha capturado
una excepción.
 Capítulo 4: Programación Avanzada en Visual Studio 2010 133

Otro ejemplo Utilizando el Try Catch

Vamos a crear el siguiente formulario, donde trabajaremos con el Try Catch

Ahora desarrollaremos el siguiente código:

Private Sub BtnNumero_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Dim Num As Integer
Try
Num = [Link]
Catch ex As Exception
If [Link] <> 0 Then
MsgBox([Link], 0, “Aviso de Alerta”)
End If
[Link]() : [Link]()
End Try
End Sub
Private Sub BtnFecha_Click(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
Dim fecha As Date
Try
fecha = [Link]
Catch ex As Exception
If [Link] <> 0 Then
MsgBox([Link], 0, “Aviso de Alerta”)
End If
[Link]() : [Link]()
End Try
End Sub

VALIDACIÓN DE CONTROLES
Ejercicio - Validación Simple
Empecemos Desarrollando una aplicación que permita validar los datos ingresados que sean numéricos
(edad y DNI), cadena (apellidos) y numéricos y cadena (dirección). Adicionalmente validaremos la tecla
ENTER, para que funcione en este ejercicio. El formulario es el siguiente:
134 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ahora empecemos a codificar los eventos por cada control:

Declaramos una variable Global al formulario

Dim tecla AsInteger

Ahora codificamos los eventos

PrivateSubtxtDNI_KeyPress(ByVal sender AsObject, ByVal e [Link].

KeyPressEventArgs) [Link]
tecla = Asc([Link])
Iftecla = 13 Then
[Link]()
ElseIfNot ((tecla>= 48 Andtecla<= 57) Or (tecla = 8)) Then
[Link] = True
EndIf
EndSub

PrivateSubtxtApellidos_KeyPress(ByVal sender AsObject, ByVal e [Link].

[Link]) [Link]
tecla = Asc([Link])
Iftecla = 13 Then
[Link]()
ElseIfNot ((tecla>= 65 Andtecla<= 90) _
Or (tecla>= 97 Andtecla<= 122) Or (tecla = 8) Ortecla = 32) Then
[Link] = True
EndIf
EndSub

PrivateSubtxtDireccion_KeyPress(ByVal sender AsObject, ByVal e [Link].

[Link]) [Link]
tecla = Asc([Link])
Iftecla = 13 Then
[Link]()
EndIf
EndSub

PrivateSubtxtEdad_KeyPress(ByVal sender AsObject, ByVal e [Link].

KeyPressEventArgs) [Link]
tecla = Asc([Link])
Iftecla = 13 Then
[Link] = True
[Link]()
ElseIfNot ((tecla>= 48 Andtecla<= 57) Or (tecla = 8)) Then
[Link] = True
EndIf
EndSub

Ahora codificamos el evento Limpiar

PrivateSubbtnLimpiar_Click(ByVal sender [Link], ByVal e [Link])

[Link]
[Link]()
[Link]()
[Link]()
[Link]()
EndSub
 Capítulo 4: Programación Avanzada en Visual Studio 2010 135

El resultado es la siguiente:

Ejercicio - Trabajando con Los Eventos de validación

Realizaremos un formulario en lo cual ingresaremos Los datos de un nuevo empleado los cuales son:
nombres, apellido paterno, apellido materno, fecha de nacimiento y estado civil. El formulario debe
validar los datos de acuerdo a los siguientes criterios:
• Los nombres y apellidos deben aceptar solo caracteres válidos.
• La edad del nuevo empleado debe estar entre 25 y 45.
• Los nombres y cualquiera de los apellidos deben contener al menos dos caracteres.

El formulario de registro debe contener dos botones: aceptar y cancelar. Si se hace clic en Aceptar el
programa debe mostrar un mensaje con todos los datos registrados y si se hace clic en Cancelar debe
cerrar el formulario sin importar si se han ingresado o no los datos.

El formulario tiene el siguiente diseño:

Ahora crearemos el código para este formulario, empecemos creando una función de validación para
los números:

Functionvalida(ByVal tecla AsShort) AsShort’Funcion que valida que solo se ingresen

letras
IfInStr(“1234567890”, Chr(tecla)) = 0 Then
valida = 0
Else
valida = tecla
EndIf
SelectCase tecla
Case8 : valida = tecla
Case13 : valida = tecla
EndSelect
EndFunction
136 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ahora codificamos el botón cancel

PrivateSubbtnCancel_Click(ByVal sender [Link], ByVal e [Link])

[Link]
Close()
EndSub

Ahora el botón aceptar, que nos mostrara el mensaje en caso de que todo sea correcto

PrivateSub btnAceptar_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
‘El boton Aceptar
Dim cad As String
cad = [Link] + “ “ + [Link] + “ “ + [Link] + “, su
edad es “ + [Link]
cad = cad + “, su estado civil es “ + [Link]
MsgBox(“Los datos son “ + cad)
EndSub

Ahora validaremos los diferentes controles para que solo se puedan ingresar caracteres y no números

PrivateSub txtNombre_KeyPress(ByVal sender AsObject, ByVal e As [Link].

[Link]) Handles [Link]
Dim tecla As Short = CShort(Asc([Link]))
tecla = CShort(valida(tecla))
If tecla<> 0 Then [Link] = True
EndSub

PrivateSub txtApellidoP_KeyPress(ByVal sender AsObject, ByVal e As [Link].

[Link]) Handles [Link]
Dim tecla As Short = CShort(Asc([Link]))
tecla = CShort(valida(tecla))
If tecla<> 0 Then [Link] = True
EndSub

PrivateSub txtApellidoM_KeyPress(ByVal sender AsObject, ByVal e As [Link].

[Link]) Handles [Link]
Dim tecla As Short = CShort(Asc([Link]))
tecla = CShort(valida(tecla))
If tecla<> 0 Then [Link] = True
EndSub

Ahora utilizando el evento Validating, validar los demas controles.

Private Sub txtNombre_Validating(ByVal sender AsObject, ByVal e As System.

[Link]) Handles [Link]
If [Link]< 2 Then
MsgBox(“Como minimo debe tener 2 caracteres”)
[Link]()
EndIf
EndSub

Private Sub txtApellidoP_Validating(ByVal sender AsObject, ByVal e As System.

[Link]) Handles [Link]
If [Link]< 2 Then
MsgBox(“Como minimo debe tener 2 caracteres”)
[Link]()
EndIf
EndSub
 Capítulo 4: Programación Avanzada en Visual Studio 2010 137

Private Sub txtApellidoM_Validating(ByVal sender AsObject, ByVal e As System.

[Link]) Handles [Link]
If [Link]< 2 Then
MsgBox(“Como minimo debe tener 2 caracteres”)
[Link]()
EndIf
EndSub

Ahora validamos el campo Fecha

PrivateSub txtFecnac_Validating(ByVal sender AsObject, ByVal e AsSystem.

[Link]) Handles [Link]
‘fecha 12/12/2011
Dim year As String = Mid([Link], 7, 4)
Dim edad As Integer
edad = 2011 - CInt(year)
If edad>= 25 And edad<= 45 Then
[Link] = CStr(edad)
[Link]()
Else
MsgBox(“La edad debe estar entre 25 y 45 años”)
[Link]()
[Link]()
EndIf
EndSub

Ejemplo de controles de errores

Diseñar un formulario que permite registrar nombres, apellidos, número de orden, examen de parcial
y examen final y presente un mensaje indicando os datos ingresados y el promedio obtenido. (15 pts.)

Para presentar el mensaje se debe tener en cuenta lo siguiente:

• Todos los datos son obligatorios.
• Los nombres deben tener al menos 02 caracteres.
• Los apellidos deben tener al menos 05 caracteres y un espacio en blanco.
• Las cajas de texto deben estar validadas de acuerdo al dato a ingresar.
• El número de orden debe ser mayor que cero.
• Utilizar el control ErrorProvider y los eventos de validación.

Crear la siguiente ventana(formulario)

138 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Adicionamos un control ErrorProvider

Ahora desarrollaremos el siguiente código

PrivateSub btnCalcular_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
‘Asiganciond e los campos para el Error
[Link](txtOrden, “”)
[Link](txtNombre, “”)
[Link](txtApellidos, “”)
[Link](txtExamenP, “”)
[Link](txtExamenF, “”)
Dim valida AsBoolean = False
If ([Link] = “”) Then
[Link](txtOrden, “Ingrese Numero de Orden”)
valida = True
EndIf
If ([Link] = “”) Then
[Link](txtNombre, “Ingrese Nombre de la Persona”)
valida = True
EndIf
If ([Link] = “”) Then
[Link](txtApellidos, “Ingrese Apellidos de la Persona”)
valida = True
EndIf
If ([Link] = “”) Then
[Link](txtExamenP, “Ingrese Nota de Examen parcial”)
valida = True
EndIf
If ([Link] = “”) Then
[Link](txtExamenF, “Ingrese Nota de Examen Final”)
valida = True
EndIf
If valida = TrueThenExitSub
‘calculo del promedio si los datos son correctos
Dim prom AsInteger
prom = (CInt([Link]) + CInt([Link])) / 2
[Link] = prom
MsgBox(“Ingreso Correcto de datos”)
EndSub

Function Letras(ByVal keyascii AsShort) AsShort

If InStr(“1234567890”, Chr(keyascii)) Then
Letras = 0
Else
Letras = keyascii
EndIf
EndFunction
 Capítulo 4: Programación Avanzada en Visual Studio 2010 139

Function Numeros(ByVal keyascii AsShort) AsShort

If InStr(“1234567890”, Chr(keyascii)) Then
Numeros = 0
Else
Numeros = keyascii
EndIf
EndFunction

PrivateSub txtNombre_KeyPress(ByVal sender AsObject, ByVal e As [Link].

[Link]) Handles [Link]
‘Validacion de que solos sea caracteres
Dim keyascii AsShort = CShort(Asc([Link]))
keyascii = CShort(Letras(keyascii))
If keyascii = 0 Then
[Link] = True
EndIf
EndSub

PrivateSub txtNombre_Validating(ByVal sender AsObject, ByVal e As System.

[Link]) Handles [Link]
If [Link] < 2 Then
MsgBox(“Debe Tener por lo Menos 2 caracteres”)
[Link]() : [Link]()
EndIf
EndSub

PrivateSub txtApellidos_KeyPress(ByVal sender AsObject, ByVal e As [Link].

[Link]) Handles [Link]
‘Validacion de que solos sea caracteres
Dim keyascii AsShort = CShort(Asc([Link]))
keyascii = CShort(Letras(keyascii))
If keyascii = 0 Then
[Link] = True
EndIf
EndSub
PrivateSub txtApellidos_Validating(ByVal sender AsObject, ByVal e As System.
[Link]) Handles [Link]
If [Link] < 5 Then
MsgBox(“Debe Tener por lo Menos 5 caracteres”)
[Link]() : [Link]()
EndIf
EndSub

PrivateSub txtOrden_KeyPress(ByVal sender AsObject, ByVal e As [Link].

KeyPressEventArgs) Handles [Link]
‘De que solo acepte Numeros
Dim keyascii AsShort = CShort(Asc([Link]))
keyascii = CShort(Numeros(keyascii))
If keyascii <> 0 Then
[Link] = True
EndIf
EndSub
140 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

PrivateSub txtOrden_Validating(ByVal sender AsObject, ByVal e As System.

[Link]) Handles [Link]
‘De quer la orden sea mayor de cero
IfCInt([Link]) <= 0 Then
MsgBox(“El Numero de Orden debe ser Mayor a 0”)
[Link]() : [Link]()
EndIf
EndSub

PrivateSub txtExamenF_KeyPress(ByVal sender AsObject, ByVal e As [Link].

[Link]) Handles [Link]
‘Validacion de que solo acepte numeros - Examen Final
Dim keyascii AsShort = CShort(Asc([Link]))
keyascii = CShort(Numeros(keyascii))
If keyascii <> 0 Then
[Link] = True
EndIf
EndSub

PrivateSub txtExamenP_KeyPress(ByVal sender AsObject, ByVal e As [Link].

[Link]) Handles [Link]
‘Validacion de que solo acepte numeros - Examen Parcial
Dim keyascii AsShort = CShort(Asc([Link]))
keyascii = CShort(Numeros(keyascii))
If keyascii <> 0 Then
[Link] = True
EndIf
EndSub
EndClass

Ejemplo – Trabajando con Videos

Vamos a realizar un ejemplo muy sencillo, en cual vamos a utiliza un componente como el Windows
Media Palyer, para realizar un formulario que permita poder visualizar un video.

Lo primero que vamos a realizar es elegir un nuevo elemento(Windows Media Payer)

Nos Ubicamos encima del ToolBox(Barra de Herramientas) y presionamos boton derecho, elegir
elemento:
 Capítulo 4: Programación Avanzada en Visual Studio 2010 141

Esto va a demorar un poco porque carga todos los componentes con lo que podemos trabajar. Luego
elegimos de la pestaña componentes y seleccionamos el siguiente ítem – Windows Media Player.

De tal manera que va a quedar anexado de la siguiente manera:

Ahora, empecemos a diseñar el formulario:

Los controles que utilizamos en este formulario son un Label(Titulo), un control Windows Media Player
y un Boton(Reporducir Video).
142 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ahora realicemos la siguiente codificación:

PrivateSub BtnReproducir_Click(ByVal sender [Link], ByVal e AsSystem.

EventArgs) [Link]
‘declaramos un openfiledialog para pdoer recuperar el archivo
DimDirectorioAsNewOpenFileDialog
DimNombreVideoAsString
[Link]()
NombreVideo = [Link]’capturamos el nomnbre del archivo
‘vizualizamos el archivo
[Link] = False
[Link] = NombreVideo
EndSub

El resultado sería el siguiente

DELEGADOS
Eventos
La mayoría de los proyectos son no lineales. En las aplicaciones Windows Forms, usted podría tener
que esperar a que un usuario haga clic en un botón o presione una tecla y, a continuación, responder
a ese evento. En aplicaciones de servidor, podría tener que esperar por una entrada de red solicitud.
Estas capacidades son proporcionados por los acontecimientos en el. NET Framework, tal y como se
describe en las siguientes secciones.

Que es Un Evento
Un evento es un mensaje enviado por un objeto para señalar la aparición de una acción. La acción
puede ser causada por la interacción del usuario, como un clic del ratón, o puede ser activado por
algún otro programa lógica. El objetivo que plantea el evento se llama el evento remitente. El objeto
que captura el evento y responde a él se le llama el caso del receptor.
 Capítulo 4: Programación Avanzada en Visual Studio 2010 143

En caso de la comunicación, el evento remitente clase no sepa a qué objeto o método recibirá (manejar)
los hechos que plantea. Lo que se necesita es un intermediario (o puntero-como mecanismo) entre
la fuente y el receptor. El. NET Framework define un tipo especial (Delegado) que proporciona la
funcionalidad de una función puntero.

Ejemplo de cómo Trabaja los Eventos

Propiedades de los controles

Control Propiedades Valor
Button (name) btnTestEvento
text Test Evento

Código del Ejercicio

Public Class Test1
Private Sub Form1_Load(ByVal sender As [Link], ByVal e As System.
EventArgs) _
Handles [Link]
‘Se agrega el manejador
AddHandler [Link], AddressOf ClickEvento
End Sub
Private Sub ClickEvento(ByVal sender As Object, ByVal e As EventArgs)
[Link](CType(sender, Button).Text)
End Sub
Private Sub btnTestEvento_Click(ByVal sender As [Link], ByVal e As System.
EventArgs) _
Handles [Link]
End Sub
End Class

Definición e implementación de delegados

La sintaxis para la definición de delegados difiere según el lenguaje. No obstante, los conceptos
fundamentales que se mostrarán a continuación son invariables independientemente del lenguaje
que se utilice:

1. Lo primero que se debe hacer para definir un delegado es indicar cuál será la firma de las funciones
a la que ese delegado podrá apuntar (por firma se entiende el tipo de datos de los parámetros que
se reciben y el tipo de datos que se retorna).
[Nivel de protección] Delegate [Sub|Function] NombreDelegado (Param1 As [Tipo],
Param2 As [Tipo], ...) {As [Tipo de retorno]}
144 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

2. El segundo paso consiste en definir las variables que almacenarán los punteros de las funciones que
se invocarán a través del delegado. Para mayor claridad llamaremos a esta variable “apuntador”.
Estas variables deben ser del “tipo” de datos del delegado (definido en el paso anterior).

[Nivel de protección] NombreApuntador As [TipoDelegado]

3. Una vez definida la firma del delegado y declarado el “apuntador” (variable del tipo del delegado)
para invocar las funciones, el tercer paso consiste en indicar cuáles serán esas funciones. Para eso
se utiliza el concepto de “sumar” métodos al apuntador (este concepto queda bastante evidente al
observar la sintaxis para realizar dicha operación en C#):

NombreApuntador = [Delegate].Combine(NombreApuntador, New TipoDelegado(AddressOf

FuncionAAgregar))

VB ofrece una sintaxis un poco más simple en el caso del uso de delegados para manejo de eventos:

AddHandler NombreApuntador, AddressOf FuncionAAgregar

4. Listo, ya se puede invocar al “apuntador” lo cual provocará la ejecución de todas las funciones que
le hayan sido agregadas. Para invocar al “apuntador” simplemente basta invocarlo por su nombre
(pasándole los parámetros requeridos definidos en la firma del delegado).

Trabajando con ListBox – Manejo de Eventos - Varios procesos con un solo Evento
Ahora este ejemplo va a desarrollar un conjunto de procesos que se encuentran en diferentes controles,
pero todos trabajados en un mismo evento, para esto realizaremos el siguiente ejemplo:

Ahora vamos a realizar lo siguiente, realizamos un doble clic sobre el botón agregar, el cual nos va a
mandar a evento clic del botón, ahora vamos a unir los llamados de los eventos de los demás controles
al mismo evento del botón agregar, de la siguiente manera:

Private Sub btnAgregar_clck(ByVal sender As [Link], ByVal e As System.

EventArgs) _
Handles [Link], [Link], [Link], [Link]
 Capítulo 4: Programación Avanzada en Visual Studio 2010 145

Ahora le vamos a cambiar de nombre al evento que no se llame btnAgrear_click sino proceso, de esta
manera:

Private Sub proceso(ByVal sender As [Link], ByVal e As [Link]) _

Handles [Link], [Link], [Link], [Link]

Ahora si codificamos el evento completamente, en el cual todos los procesos se encunetran en un solo
evento:

Private Sub Proceso(ByVal sender As [Link], ByVal e As [Link]) _

Handles [Link], [Link], [Link], [Link]
‘Forma de Trabajar con un solo evento 4 controles del mismo tipo
Dim BotonSeleccionado As Button
BotonSeleccionado = CType(sender, Button) ‘envio el objeto que se esta
trabajando
Select Case [Link]
Case “btnAgregar”
[Link]([Link])
[Link] = “” : [Link]()
Case “btnEliminar”
If [Link] <> -1 Then
[Link]([Link])
End If
Case “btnLimpiar”
[Link]()
Case “btnSalir”
End
End Select

Ahora ejecútemelos y veamos que el funcionamiento sigo siendo igual que los ejemplos anteriores de
listbox

Delegados de Visual Basic

Los delegados son una forma de puntero de función orientado a objetos que permite invocar una
función indirectamente mediante una referencia a la función. Los delegados se pueden utilizar para
enlazar controladores de eventos y pasar un procedimiento de un procedimiento a otro.
146 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Un delegado es una clase que puede contener una referencia a un método. A diferencia de otras
clases, un delegado de clase tiene una firma, y que puede contener referencias sólo a los métodos
que coincidan con su firma. Un delegado no es, pues, equivalente a un tipo libre de función o un
puntero de llamada. Mientras que los delegados tienen otros usos, el debate aquí se centra en el caso
de manipulación de la funcionalidad de los delegados. Un delegado de declaración es suficiente para
definir un delegado de clase. La declaración suministros a la firma del delegado, y el Common Language
Runtime proporciona la aplicación. El siguiente ejemplo muestra un evento delegado de declaración:

Public Sub Button1_Click(sender As Object, e As EventArgs)

EventHandler es un delegado predefinido que específicamente representa un método manejador de

evento para un evento que no genera los datos. Si su caso no genera los datos, usted debe proporcionar
sus propios datos de eventos de tipo y, o bien crear un delegado cuando el tipo del segundo parámetro
es su costumbre tipo, o se debe utilizar el delegado genérico EventHandler de clase y sustituir su
costumbre para el tipo genérico tipo de parámetro.

Los delegados y el operador AddressOf

Los delegados son objetos que puede utilizar para llamar a los métodos de otros objetos. Algunas
veces están descritos como punteros de función con seguridad de tipos porque son parecidos a los
punteros de función utilizados en otros lenguajes de programación. Pero a diferencia de los punteros
de función, los delegados de Visual Basic son un tipo de referencia basado en la clase [Link].
Los delegados pueden hacer referencia a los dos métodos compartidos, métodos a los que se pueden
llamar sin una instancia específica de una clase, y a métodos de instancia.

Los delegados son útiles en situaciones donde es necesario un intermediario entre el procedimiento
que realiza una llamada y el procedimiento que la recibe. Por ejemplo, puede que desee que un
objeto que provoca eventos sea capaz de llamar a diferentes controladores de eventos bajo diferentes
circunstancias. Desgraciadamente, el objeto que provoca los eventos no puede saber con anticipación
qué controlador de eventos está controlando un evento específico. Visual Basic le permite asociar
dinámicamente controladores de eventos con eventos creando un delegado para el usuario cuando
utiliza la instrucción AddHandler. En tiempo de ejecución, el delegado remite las llamadas al controlador
de eventos adecuado.

Ejemplo de Delegados – como Trabajar

Propiedades de los controles

Controles Propiedades Valor
Button Text Invocar

Código para el manejo de Eventos

Primero Creamos el Delegado que nos va a permitir invocar a otra funciones

‘Creacion de Delegado
Delegate Function MathOperator(ByVal x As Double, ByVal y As Double) As Double
 Capítulo 4: Programación Avanzada en Visual Studio 2010 147

Luego Creamos 2 funciones, Una para sumar números y el otro para restar números

‘Funcion Sumar un Numero

Function AddNumber(ByVal x As Double, ByVal y As Double) As Double
Return x + y
End Function

‘Funcion Restar un Numero

Function SubstrNumber(ByVal x As Double, ByVal y As Double) As Double
Return x - y
End Function

Creamos el evento que permite invocar al delegado y hacer la referencia con los otras 2 funciones que
se han creado

‘Funcion donde se invoca al delegado

Sub DelegateTest(ByVal x As Double, ByVal op As MathOperator, ByVal y As Double)
Dim ret As Double
ret = [Link](x, y)
MsgBox(ret)
End Sub
Protected Sub test()
DelegateTest(5, AddressOf AddNumber, 3)
DelegateTest(5, AddressOf SubstrNumber, 3)
End Sub

Ahora realizamos el código en el botón donde la va a invocar

Private Sub Button1_Click(ByVal sender As [Link], ByVal e As [Link]) _

Handles [Link]
test()
End Sub

Declarar eventos que utilicen un tipo de delegado existente

En algunas situaciones, puede que desee declarar un evento para que utilice un tipo de delegado
existente como delegado subyacente. La sintaxis siguiente describe cómo hacerlo:
Delegate Sub DelegateType()
Event AnEvent As DelegateType

Esto resulta útil cuando se desea en rutar diversos eventos hacia el mismo controlador.

Pasar procedimientos a otro procedimiento en Visual Basic.

Este ejemplo muestra cómo se utilizan los delegados para pasar un procedimiento a otro.

Un delegado es un tipo que puede utilizar como cualquier otro tipo en Visual Basic. El operador
AddressOf devuelve un objeto de delegado cuando se aplica a un nombre de procedimiento.

Este ejemplo tiene un procedimiento con un parámetro de delegado que puede llevar una referencia
a otro procedimiento obtenido con el operador AddressOf.
148 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

CREANDO UN EXPLORADOR
A continuación vamos a desarrollar algunos ejemplos de cómo podemos realizar una aplicación que
nos permita explorar la información que se encuentra en el computador.

Ejemplo Inicial – Explorador de Datos Simple

Bueno para empezar a desarrollar el ejemplo, primero vamos a diseñar el siguiente formulario en el
cual se mostrara el explorador:

Ahora vamos a empezar a codificar los siguientes eventos:

En el evento load del formulario:

Private Sub FrmExplorador_Load(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
‘Mostrar el directorio Actual
[Link] = CurDir()
End Sub

En el botón btncambiar, realizamos el siguiente script

Private Sub btnCambiar_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Dim NuevaRuta As String ‘ nombre de la carpeta
Dim MensajeError As String ‘mensaje de error
Dim Elemento As String ‘el nombre del archivo
Try
NuevaRuta = [Link] ‘Almacena el path que el usuario a ingresado
ChDir(NuevaRuta) ‘Cambia la carpeta actual
‘Si no se ingreso el directorio muestra mensaje de error
Catch ex As Exception When NuevaRuta = “”
MensajeError = “Debes Indicar la Ruta”
Catch
MensajeError = “Debe Ingresar Una ruta valida, Intentas Acceder a unidad
diferente”
Finally
‘Muestra el mensaje de Error si existe
If MensajeError <> “” Then
 Capítulo 4: Programación Avanzada en Visual Studio 2010 149

MsgBox(MensajeError) : [Link] = “”
End If
End Try
[Link]()
Elemento = Dir(“*.txt”) ‘Chequear solo archivos de texto(*.txt)
If Elemento = “” Then
MensajeError = “No se encontraron archivos de texto” : MsgBox(MensajeError)
End If
Do Until Elemento = “” ‘Navegar a traves del contenido del directorio
[Link](Elemento) ‘Agregar a la Lista
Elemento = Dir() ‘Se desplaza al siguiente archivo
Loop
End Sub

En el botón btnexaminar, codificamos lo siguiente:

Private Sub btnExaminar_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Dim Archivo As Object
Archivo = [Link]
If Archivo Is Nothing Then ‘Verifico q se ha seleccionado un archivo
MsgBox(“No ha seleccionado un Archivo”)
Exit Sub
End If
‘Variables para presentar resultados
Dim cadenaAtributos As String = “Los Atributos del Archivo son: “
Dim UltAcceso As String = “El Ultimo Acceso fue: “
Dim LongArchivo As String = “La Longitud del archivo en Bytes es: “
Dim PrimLinea As String = “Los Primeros 80 caracteres son: “
Dim Atributos As FileAttribute
Dim resultadosAtributos As String
Dim UltimoAcceso As Date
Dim longitud As Long
Dim PrimeraLinea , cadenaFinal ,MensajeError As String
‘verificar los atributos
If [Link] = True Then
Atributos = GetAttr(Archivo) ‘Capturar los atributos del archivo
If Atributos = 1 Then
resultadosAtributos = “ReadOnly”
ElseIf Atributos = 32 Then
resultadosAtributos = “Archive”
ElseIf Atributos = 34 Then
resultadosAtributos = “ReadOnly and Archive”
Else
resultadosAtributos = “Normal”
End If
End If
‘adicionamos la informacion para el Msg Final
cadenaFinal = cadenaAtributos + resultadosAtributos + “,” + vbCr
‘chequea Ultimo acceso
If [Link] = True Then UltimoAcceso = FileDateTime(Archivo)
‘adicionamos la informacion para el Msg Final
cadenaFinal = cadenaFinal + UltAcceso + UltimoAcceso + “,” + vbCr
‘Chequeamo las Longitud
If [Link] = True Then longitud = FileLen(Archivo)
‘adicionamos la informacion para el Msg Final
cadenaFinal = cadenaFinal + LongArchivo + CType(longitud, String) + “,” + vbCr
‘chequear la primera linea
If [Link] = True Then
Try
FileOpen(1, Archivo, [Link]) ‘Abre el archivo
PrimeraLinea = (InputString(1, 15)) ‘recupera la primera linea del
registro
150 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Catch ex As Exception
MensajeError = “Algun error ocurre en el archivo. Aseguerese que no
este vacio”
MsgBox([Link])
Exit Sub
End Try
FileClose(1) ‘Cierra el Archivo
End If
‘adicionamos la informacion para el Msg Final
cadenaFinal = cadenaFinal + PrimLinea + PrimeraLinea + vbCr
If cadenaFinal = “” Then
MsgBox(“No Selecciono ninguna Casilla”)
Else
MsgBox(cadenaFinal)
End If
End Sub

Cuando lo ejecutemos nos mostrará de la siguiente manera:

Ejemplo de Explorador – Explorador Avanzado

Ahora vamos a realizar un explorador un poco más avanzado que el ejemplo anterior, para esto vamos
a realizar el siguiente diseño:
 Capítulo 4: Programación Avanzada en Visual Studio 2010 151

Ahora vamos a empezar a codificar, el formulario para que funcione como un explorador:

En el Evento load realizamos lo siguiente:

Public Class frmExplorador2

Private Sub frmExplorador2_Load(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
LlenarArbol() ‘Treeview
AgregarArchivos(“c:\”) ‘[Link]) ‘para el ListView
End Sub

Ahora vamos a crear la subrutina LlenarArbol:

Private Sub LlenarArbol()

[Link]()
[Link]()
‘Drives Principales
Dim astrDives As String() = [Link]()
Dim strDrive As String
For Each strDrive In astrDives
Dim tnDrive As New TreeNode(strDrive, 0, 0)
[Link](tnDrive)
AgregarDir(tnDrive)
If strDrive = “c:\” Then [Link] = tnDrive
Next
[Link]()
End Sub

Ahora vamos a a crear un evento que se llama AgregarDir

Private Sub AgregarDir(ByVal tn As TreeNode)

[Link]()
Dim strpath As String = [Link] ‘la ruta de la seleccion
Dim diDirectory As New DirectoryInfo(strpath) ‘Devuelve la informacion del
directorio
Dim aDir() As DirectoryInfo ‘Arrays para las subcarpetas
Try
aDir = [Link]() ‘obtiene todos los subdirectorios
Catch ex As Exception
Exit Sub
End Try
Dim di As DirectoryInfo
For Each di In aDir
Dim tnDir As New TreeNode([Link], 1, 2) ‘Crea un nodo y pasa el nombre
y la imagen
[Link](tnDir) ‘Agregar el Nodo Creado
Next
End Sub

Ahora creamos otra subrutina que se llama AgregarArchivos

‘LLenar los archivos del directorio seleccionado

Private Sub AgregarArchivos(ByVal vDir As String)
‘por defecto esta seleccionado el directorio raiz de c:\
[Link]()
‘Obtener los directorios o sub carpetas
Dim dDirectories As New DirectoryInfo(vDir)
Dim afiFiles() As FileInfo ‘Arrays de Archivos
Try
152 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

‘Arrays de todos los archivos

afiFiles = [Link]()
Catch
Return
End Try
Dim fi As FileInfo
For Each fi In afiFiles
‘Crear un Listview y asignarle el nombre del archivo
Dim lvi As New ListViewItem([Link])
‘tamaño y fecha de modificacion : length - lastwritetime
[Link]([Link](“N0”))
[Link]([Link]())
‘Atributos
Dim strAttr As String = “”
If ([Link] And [Link]) <> 0 Then strAttr += “A”
If ([Link] And [Link]) <> 0 Then strAttr += “H”
If ([Link] And [Link]) <> 0 Then strAttr += “R”
If ([Link] And [Link]) <> 0 Then strAttr += “S”
[Link](strAttr)
[Link](lvi) ‘añadir el items al listview
Next fi
End Sub

Y por último programamos el evento AfterSelect del treeview

Private Sub tvDir_AfterSelect(ByVal sender As [Link], ByVal e As System.

[Link]) Handles [Link]
AgregarArchivos([Link])
End Sub

El formulario quedara de la siguiente manera cuando se ejecute:

 Capítulo 4: Programación Avanzada en Visual Studio 2010 153

TRABAJANDO CON EL CONTROL LISTVIEW

El control ListView muestra una lista de elementos con iconos. Puede utilizar una vista de lista para
crear una interfaz de usuario similar al panel derecho del Explorador de Windows.

El control ListView es un control de lista que tiene mucha versatilidad, se puede utilizar hasta en 4
vistas diferentes: LargeIcon, Details, SmallIcon y List (Iconos grandes, Detalle, Iconos pequeños y Lista).
Las mismas opciones están incluidas en el botón Vistas del Explorador de Windows.

El control ListView se usa generalmente ligado a una o dos Listas de Imagenes incluídas en controles
ImageList, estos permiten mostrar los íconos de cada elemento cuando se selecciona las opciones de
LargeIcon y SmallIcon.

Ahora vamos a desarrollar 2 ejemplos para conocer como trabaja el ListView.

Ejemplo inicial con el ListView

Vamos a crear, un formulario simple en el cual le vamos a adicionar un control listview de la siguiente
manera:

Ahora vamos a codificar el listview de la siguiente manera:

PrivateSub frmListView1_Load(ByVal sender [Link], ByVal e AsSystem.

EventArgs) [Link]
‘Diseño de ListView
[Link] = [Link]
[Link] = True
‘Creacion de Columnas, con tamaño
[Link](“Primer Nombre”).Width = 100
[Link](“Segundo Nombre”).Width = 100
‘Datos de Ingreso de datos al Listbox
[Link](“Fatima”).[Link](“Huachez”)
[Link](“Luis”).[Link](“Garcia”)
[Link](“Andre”).[Link](“Sanchez”)
EndSub
154 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ejemplo - Un ejemplo más avanzado del Listview

Ahora vamos a crear el siguiente formulario, para seguir conociendo el control listview para esto vamos
a desarrollar el siguiente formulario:

Ahora vamos a codificar de la siguiente manera, empecemos con el evento Load del Formulario para
cargar el diseño del ListView

PrivateSub frmListView2_Load(ByVal sender [Link], ByVal e AsSystem.

EventArgs) [Link]
‘DiseñodelListview
[Link] = [Link]
[Link] = True
‘Adicionamos las columnas y el tamaño de la columna
[Link](“Nro. Orden”).Width = 80
[Link](“Nota 1”).Width = 80
[Link](“Nota 2”).Width = 80
[Link](“Promedio”).Width = 80
EndSub

Ahora el botón Procesar vamos a codificarlo

PrivateSubBtnProcesar_Click(ByVal sender [Link], ByVal e AsSystem.

EventArgs) [Link]
‘Creacion de un Arryas
DimTabla(10, 2), F, C AsInteger
DimPromAsSingle
‘Ingresar valores de notas, utilizando una funcion aleatoria
For F = 0 To 9
For C = 0 To 1
Tabla(F, C) = CInt(Rnd() * 20)
Next
Next
‘ Carga de la tabla al control ListView(LsvTabla), ademas del promedio
For F = 0 To 9
[Link](Format(F + 1, “00”))
For C = 0 To 1
[Link](F).[Link](Format(Tabla(F, C), “00”))
Next
Prom = (Tabla(F, 0) + Tabla(F, 1)) / 2 ‘hallamos el promedio
[Link](F).[Link](Format(Prom, “00.00”))
Next
EndSub
 Capítulo 4: Programación Avanzada en Visual Studio 2010 155

El formulario quedaría de la siguiente manera:

SERVICIOS DE WINDOWS
Como seguramente sabrás, entre los tipos de proyectos que Visual Studio .NET 2010 nos permite
crear, se encuentran los Servicios de Windows, anteriormente conocidos como Servicios NT.

Para refrescarte la memoria, te diré que un Servicio de Windows no es una aplicación normal de
Windows, ya que no tiene interfaz gráfica de cara al usuario y tampoco es una especie de Servicio Web
que funciona en Windows en lugar de hacerlo en un sitio de Internet. Los Servicios de Windows son
aplicaciones que funcionan sin interactuar directamente con el usuario y por regla general se inician
junto con el sistema, sin que ningún usuario tenga que iniciarlo.

En este ejemplo veremos es cómo crear e instalar un Servicio de Windows y también cómo comunicarnos
con ese Servicio de Windows, para ello crearemos una pequeña utilidad que nos permita ver los
Servicios de Windows instalados en nuestro equipo, así como los instalados en otros equipos a los
que tengamos acceso, de forma que podamos saber si están o no iniciados e incluso poder iniciarlos,
pausarlos, detenerlos, etc.

Administrar los Servicios de Windows

Como te acabo de comentar, vamos a crear una pequeña utilidad en la que mostraremos los Servicios
de Windows que estén actualmente registrados en nuestro equipo o en cualquiera de los equipos a los
que tengamos acceso. Mostraremos la información sobre los servicios, así como el estado actual en
que se encuentra: si está iniciado o no. Mediante una serie de botones podremos iniciarlos, pausarlos,
detenerlos, etc. Dependiendo de que podamos realizar esas acciones, los botones estarán habilitados
o deshabilitados.

Como sabrás, la administración de los Servicios de Windows podemos hacerla desde Servicios en
Herramientas Administrativas, desde allí podemos iniciar, detener, pausar, etc. cualquiera de los
servicios que estén configurados en el sistema, con nuestra utilidad podremos hacer todas esas cosas,
o al menos lo intentaremos.

No pienses que esta utilidad suplantará a la incluida en el sistema, simplemente nos servirá, para entre
otras cosas, saber cómo usar una de las clases incluidas en el .NET Framework para “interactuar” con
los Servicios de Windows: la clase ServiceController.
156 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ejemplo Completo de cómo utilizar los Servicios de Windows

Bueno desarrollemos un ejercicio que me permita poder controlar los servicios con los cuales
cuenta mi computadora, para poder esto diseñemos la siguiente formulario, que se llamara
FrmAdministraServicios:

Luego de esto desarrollemos 2 clases para poder trabajar todo el proceso , la primera clase se llama
PRUEBASW

Se cargan las siguientes clases

Imports [Link]
Imports [Link]

Se declaran las siguientes variables

Private WithEvents temporizador As [Link]

Private intervalo As Integer = 50000
‘ la aplicación que vamos a comprobar
Private aplicación As String
‘ si se debe hacer la comprobación
Private comprobar As Boolean

Ahora empecemos a realizar la codificación del formulario:

Protected Overrides Sub OnStart(ByVal args() As String)

‘ Agregar código aquí para iniciar el servicio. Este método debería poner en
movimiento
‘ los elementos para que el servicio pueda [Link] args() estarán los
argumentos pasados al servicio
‘Se indicará en la forma:aplicación [/C] para iniciar la comprobación de la
aplicación indicada [aplicación] /NC para detener la comprobación
Try
Dim s As String = args(0).Trim
If s <> “” Then
Dim i As Integer
‘ primero averiguamos si se debe o no comprobar
If [Link](“/C”) > -1 Then
 Capítulo 4: Programación Avanzada en Visual Studio 2010 157

comprobar = True
Else
comprobar = False
End If
i = [Link](“/”) ‘ según se haya o no indicado el segundo parámetro
Select Case i
Case -1
‘ no se indica el segundo parámetro debe ser el nombre de
la aplicación
aplicación = s : comprobar = True
Case Is > 0
‘ se indica la aplicación, debe estar antes de la barra
aplicación = [Link](0, i - 1).Trim
End Select
End If
Catch
‘ si se produce un error, no asignar nada, se usarán los valores
anteriores, si hay...
End Try
‘ empezar con un intervalo pequeño para que se inicie el evento del
temporizador
‘ nada más empezar, después se asignará el valor configurado
temporizador = New [Link](100)
[Link]()
End Sub

Protected Overrides Sub OnStop()

‘ Agregar código aquí para realizar cualquier anulación necesaria para detener el
servicio.
[Link]()
End Sub

Continuamos codificando los eventos que estamos codificando

Protected Overrides Sub OnPause()

‘ si se detiene temporalmente el servicio
[Link]()
End Sub

Protected Overrides Sub OnContinue()

‘ si s continúa el servicio, volver a iniciar el temporizador
[Link]()
End Sub

Private Sub temporizador_Elapsed(ByVal sender As Object, _

ByVal e As [Link]) _
Handles [Link]
‘ deshabilitar temporalmente el timer
[Link] = False
‘ asignar el nuevo valor del temporizador
If intervalo <> [Link] Then
[Link] = intervalo
End If
‘ si se debe comprobar si está en ejecución
If comprobar Then
Try
Dim procesos() As Process
Dim nombreProceso As String
‘ el nombre del proceso suele ser el nombre de la aplicación sin la
extensión
nombreProceso = [Link](aplicación)
procesos = [Link](nombreProceso)
158 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

If ([Link] = 0 OrElse (procesos Is Nothing)) Then

‘ si no está en ejecución, iniciarlo
‘ IMPORTANTE:
‘ Los ejecutables iniciados con un Servicio de Windows
‘ no se muestran: se ejecutan ocultos.
Dim proceso As New Process()
[Link] = aplicación
[Link]()
End If
Catch
End Try
End If
‘ volver a habilitar el timer
[Link] = True
End Sub

Ahora crearemos la siguiente clase INSTALLERPRUEBASW

Imports [Link]
Imports [Link]
Imports [Link]

Private serviceInstaller1 As ServiceInstaller

Private processInstaller As ServiceProcessInstaller

Public Sub New()

‘ Ejemplifican los instaladores de proceso y servicios.
processInstaller = New ServiceProcessInstaller()
serviceInstaller1 = New ServiceInstaller()
‘ Los servicios se ejecutará bajo el sistema
[Link] = [Link]
‘ El servicio se iniciará manualmente
‘ para que se inicie automáticamente, especificar el valor:
‘ [Link]
[Link] = [Link]
‘ Servicename debe ser igual a las clases ServiceBase derivadas.
[Link] = “PruebaSW”
‘ Añadir instaladores para la [Link] Orden no es importante.
[Link](serviceInstaller1)
[Link](processInstaller)
End Sub

Ahora empecemos a codificar el programa principal en formulario frmAdministraServicio

Option Strict On
Imports [Link]

Private servicios() As ServiceController

Private servicio As ServiceController
Private itemActual As ListViewItem

Private Sub Form_Load(ByVal sender As [Link], ByVal e As [Link]) _

Handles [Link]
With serviciosLv
.View = [Link]
.FullRowSelect = True
.GridLines = True
.LabelEdit = False
.HideSelection = False
.[Link]()
 Capítulo 4: Programación Avanzada en Visual Studio 2010 159

.[Link](“Servicio”, 100, [Link])

.[Link](“Estado”, 60, [Link])
.[Link](“Descripción”, 200, [Link])
.[Link](“Tipo de servicio”, 100, [Link])
.[Link](“Equipo”, 70, [Link])
End With
[Link] = False : [Link] = False
[Link] = False : [Link] = False
[Link] = False
[Link] = False
[Link] = “”
[Link] = “”
‘mostrar Procedimiento
mostrarServicios()
End Sub

Private Sub refrescarBtn_Click(ByVal sender As [Link], _

ByVal e As [Link]) _
Handles [Link]
mostrarServicios([Link])

End Sub

Private Sub cerrarBtn_Click(ByVal sender As [Link], _

ByVal e As [Link]) _
Handles [Link]
Close()
End Sub

Ahora codifiquemos el Boton Iniciar

Private Sub iniciarBtn_Click(ByVal sender As [Link], _

ByVal e As [Link]) _
Handles [Link]
Try
[Link]()
comprobarEstado(servicio)
Catch ex As Exception
[Link]([Link], “Error al iniciar el servicio”)
End Try
End Sub

Ahora desarrollamos los códigos para los botones Iniciar con Parámetros y el botón detener

Private Sub iniciarParametrosBtn_Click(ByVal sender As [Link], _

ByVal e As [Link]) _
Handles [Link]
Try
If [Link] <> “” Then
Dim args(0) As String
‘
args(0) = [Link]
[Link](args)
Else
[Link]()
End If
comprobarEstado(servicio)
Catch ex As Exception
[Link]([Link], “Error al iniciar el servicio con parámetros”)
End Try
End Sub
160 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ahora el boton detener

Private Sub detenerBtn_Click(ByVal sender As [Link], _

ByVal e As [Link]) _
Handles [Link]
Try
If [Link] Then
[Link]()
comprobarEstado(servicio)
End If
Catch ex As Exception
[Link]([Link], “Error al detener el servicio”)
End Try
End Sub

Ahora acá trabajamos el botón Pausar, Continuar y Reiniciar

Private Sub pausarBtn_Click(ByVal sender As [Link], _

ByVal e As [Link]) _
Handles [Link]
Try
If [Link] Then
If [Link] = [Link] Then
[Link]()
comprobarEstado(servicio)
End If
End If
Catch ex As Exception
[Link]([Link], “Error al pausar el servicio”)
End Try
End Sub
Private Sub continuarBtn_Click(ByVal sender As [Link], _
ByVal e As [Link]) _
Handles [Link]
Try
If [Link] Then
If [Link] = [Link] Then
servicio.[Continue]()
comprobarEstado(servicio)
End If
End If
Catch ex As Exception
[Link]([Link], “Error al continuar el servicio”)
End Try
End Sub
Private Sub reiniciarBtn_Click(ByVal sender As [Link], _
ByVal e As [Link]) _
Handles [Link]
If [Link] = [Link] Then
Try
[Link]()
[Link]()
Catch ex As Exception
[Link]([Link], “Error al reiniciar el servicio”)
End Try
End If
If [Link] = [Link] Then
Try
[Link]()
Catch ex As Exception
[Link]([Link], “Error al reiniciar el servicio”)
End Try
End If
comprobarEstado(servicio)
End Sub
 Capítulo 4: Programación Avanzada en Visual Studio 2010 161

Ahora trabajaremos en el evento del Listview para modificar la selección:

Private Sub serviciosLv_SelectedIndexChanged(ByVal sender As [Link], _

ByVal e As [Link]) _
Handles [Link]
Try
itemActual = [Link](0)
servicio = DirectCast([Link], ServiceController)
comprobarEstado(servicio)
Catch
itemActual = Nothing
comprobarEstado()
End Try
End Sub
‘
Private Sub mostrarServicios()
mostrarServicios(“”)
End Sub

Private Sub mostrarServicios(ByVal equipo As String)

Dim i As Integer
Dim lvi As ListViewItem
‘
If equipo = “” Then equipo = “.”
‘
servicios = [Link](equipo)
[Link]()
For i = 0 To [Link] - 1
lvi = [Link](servicios(i).ServiceName)
[Link](servicios(i).[Link])
[Link](servicios(i).DisplayName)
[Link](servicios(i).[Link])
[Link](servicios(i).MachineName)
‘
‘ guardar una referencia del servicio en la propiedad Tag
[Link] = servicios(i)
Next
End Sub

Crearemos las siguientes subrutinas

Private Sub comprobarEstado()

[Link] = False
[Link] = False
[Link] = False
[Link] = False
[Link] = False
[Link] = False
End Sub

Private Sub comprobarEstado(ByVal elServicio As ServiceController)

Dim servStatus As ServiceControllerStatus
[Link] = False : [Link] = False
[Link] = False : [Link] = False
[Link] = False : [Link] = False
‘
Try
servicio = elServicio
[Link]()
servStatus = [Link]
If [Link] Then
[Link] = (servStatus = [Link])
162 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

[Link] = (servStatus = [Link])

End If
If [Link] Then
[Link] = (servStatus = [Link])
End If
[Link] = (servStatus = [Link])
[Link] = [Link]
[Link] = [Link]
Catch
‘[Link] = False : ‘[Link]
= False
‘[Link] = False : ‘[Link] = False
‘[Link] = False : ‘[Link] = False
End Try
If Not itemActual Is Nothing Then
Try
[Link](1).Text = [Link]
Catch ex As Exception
[Link]([Link], “Error al comprobar el estado del
servicio”)
End Try
End If
End Sub
 CAPÍTULO

5
Menus, Forms
Avanzados e Hilos
 CAPÍTULO

5 Menus, Forms
Avanzados e Hilos
TRABAJANDO CON MENUS Y FORMULARIOS AVANZADOS
Creación de Formularios MDI
Para crear un formulario tipo MDI, este debe tener asignado en la propiedad IsMdiContainer como
verdadero, este transforma a un formulario como un contenedor de formularios.

Para involucrar un nuevo formulario como involucrado dentro de un MDI, este se debe establecer en
la propiedad MdiParent del formulario.

Uso del control MenuStrip

Los menús exponen la funcionalidad a sus usuarios presionando comandos agrupados por un tema
común. El control MenuStrip es nuevo en esta versión de Visual Studio y .NET Framework. Con el
control puede crear fácilmente menús como los de Microsoft Office.

El control MenuStrip admite la interfaz de múltiples documentos (MDI) y combinación de menús, la

información sobre herramientas y el desbordamiento. Puede mejorar la utilidad y legibilidad de sus
menús agregando teclas de acceso, teclas de método abreviado, marcas de verificación, imágenes y
barras separadoras.
166 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Aunque el control MenuStrip reemplaza y agrega la funcionalidad al control MainMenu, éste se

conserva a efectos de compatibilidad con versiones anteriores y uso futuro, según sea el caso.

Agregando elementos predefinidos

Elementos de un MenuStrip
MenuItem
ComboBox
Separador
TextBox
 Capítulo 5: Menus, Forms Avanzados e Hilos 167

Cuadro de Opciones para Mantenimiento de un MenuStrip

Para la edición manual de los elementos se debe seleccionar el MenuStrip Click derecho y seleccionamos
“Edición de Ítems” o desde el cuadro de propiedades en “Ítems” y tendremos el siguiente cuadro para
ver el “El cuadro de edición”.

MIEMBROS IMPORTANTES DEL CONTROL MENUSTRIP

ToolStripMenuItem
Representa una opción seleccionable mostrada en un MenuStrip. A nivel clases inicializa una nueva
instancia de la clase ToolStripMenuItem con el nombre especificado que muestra la imagen y el texto
especificados, y realiza la acción especificada cuando se hace clic en ToolStripMenuItem, entre otras
instancias principales.

ToolStripControlHost
Aloja controles personalizados o controles de formularios Windows Forms.
168 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Uso del control ToolStrip

Es un contenedor para los objetos de barra de herramientas de Windows. Se debe utilizar ToolStrip
y sus clases asociadas para crear barras de herramientas que pueden tener una apariencia y un
comportamiento de Windows XP, Office, Internet Explorer.

Los controles ToolStrip también proporcionan una experiencia completa en tiempo de diseño que
incluye la activación y edición en contexto, diseño personalizado, y uso compartido del espacio
horizontal o vertical dentro de un ToolStripContainer especificado.

Agregando elementos predefinidos

Elementos de un ToolStrip
El ToolStrip, es un control de contenedores de los siguientes objetos:

ToolStripButton,
ToolStripComboBox,
ToolStripSplitButton,
ToolStripLabel,
ToolStripSeparator,
ToolStripDropDownButton,
ToolStripProgressBar
ToolStripTextBox.
 Capítulo 5: Menus, Forms Avanzados e Hilos 169

Ejemplo de Diseño de un ToolStrip

Agregando Elementos a un ToolStrip

Al usar uno de los botones del ToolStrip de diseño anterior, en el botón ir podríamos colocar lo siguiente
(previamente colocar el control WebBrowser)
170 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Uso del Control StatusStrip

El StatusStrip reemplaza y amplía el control StatusBar de versiones anteriores, se conserva StatusBar a
efectos de compatibilidad con versiones anteriores y uso futuro, en su caso.

Un control StatusStrip muestra información acerca del objeto que se está mostrando en un formulario,
los componentes del objeto o información contextual relativa a la operación de ese objeto en la
aplicación. Normalmente, un control StatusStrip está formado por objetos ToolStripStatusLabel,
además de los:
ToolStripDropDownButton
ToolStripSplitButton
ToolStripProgressBar.

Trabajando con formularios Login forms

Primero Iniciemos una nueva aplicación, la cual al momento de crearla por defecto nos mostrara
un formulario, el cual no va a sufrir ninguna modificación, solo se cambiara de nombre que será
frmMain.
 Capítulo 5: Menus, Forms Avanzados e Hilos 171

Luego adicionaremos un nuevo formulario el cual será un tipo distinto al primero, presionaremos
botón derecho agregar elemento y elegiremos un tipo de formulario que será Loginform que llevara
por nombre frmLogin

Luego haremos unas modificaciones a la venta Loginform, para que nos quede de la siguiente manera:

Ahora codificaremos de la siguiente manera

172 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ahora creo un Modulo dentro de la aplicación, para que desde ahí se pueda cargar los formularios
según las condiciones:

Module SubMain
Sub Main()
Dim dlg as New frmlogin
If [Link]() = [Link] then
‘Si es correcto el logeado se va a efectuar el
‘Displayado de la Ventana
Dim frm as new frmMain
[Link]()
End If
End Sub
End Module

Formulario Splash
Lo primero que debemos hacer es crear una ventana Principal, la cual la llamaremos frmPrincipal, y un
diseño simple, porque a nosotros nos intera conocer el funcionamiento de la ventana de tipo Splash
Screen.
 Capítulo 5: Menus, Forms Avanzados e Hilos 173

Ahora agregaremos desde el Soluction Explorer, un nuevo item, la cual sera una ventana de tipo Splash
Screen, a la cual le daremos por nombre SplashForm.

Nos mostrará una ventana de la siguiente manera, es predefinida

La cual podemos modificar algunas de las características (propiedades) de esta ventana para quedar de
la siguiente manera (las propiedades son sencillas de cambiar):
174 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Aunque puede resultar obvio el establecer al Splash Form como el Objeto inicial de la aplicación, y desde
el mismo lanzar después el formulario principal con el cual el usuario interactuará con la aplicación,
esto no es lo adecuado. El problema es que cuando establecemos el objeto inicial se indica el objeto
a partir del cual se inicia el bucle de mensajes de la aplicación, por lo que al destruirse dicho objeto se
termina la aplicación. Por lo anterior y otras razones el objeto inicial debe ser el formulario principal y
no el Splash Form.

Ahora empecemos con la codificación, en la ventana principal, codificamos lo siguiente, lo primero

que vamos hacer es codificar, lo primero que debemos hacer es crear una subrutina para controlar el
tiempo de la ventana

Por otro lado debemos controlar el tiempo de despliegue del Splash Form para lo cual existen dos
opciones:
Con el uso de un componente temporizador (Timer) alojado en el Splash Form.
Con el uso de [Link] desde el formulario principal.

Cualquiera de los dos formas es válida, pero siempre se debe procurar controlar desde formulario
principal el tiempo que se despliega el Splash Form. Si se utiliza un Timer dentro del Splash Form el
mismo se debe desplegar de manera modal utilizando el método ShowDialog, mientras que el uso de
[Link] nos permite desplegar el Splash Form de manera no modal con el método Show.

Imports [Link]
Public Class frmPrincipal
Private Sub ShowSplash()
Dim fsplash as new splashForm
[Link] = Me
[Link]()
[Link]()
[Link](1000)
[Link]()
[Link]()
End Sub

Este proceso lo que se hace es que se despliegue en forma no modal, para eso implementamos un
método privado dentro de clase del formulario principal que se encargará de instanciar y mostrar
el Splash Form por una determinada cantidad de tiempo, en este caso 1 segundo(esto se puede
aumentar).

Por último sólo resta llamar el método anterior al inicio del manejador del evento Load del formulario
principal.

Private Sub frmPrincipal_Load(byval sender as object, e as EventArgs) Handles MyBase.

Load
ShowSplash()
End Sub
 Capítulo 5: Menus, Forms Avanzados e Hilos 175

TRABAJANDO CON HILOS (THREADING)

Definición
Los programadores de Visual Basic han creado aplicaciones sincronías en las que las tareas del
programa se ejecutan de forma secuencial. Las aplicaciones multiproceso pueden ser más eficaces, ya
que permiten ejecutar varias tareas de forma más o menos simultánea.

Threading es un concepto importante en el desarrollo de software. El concepto básico detrás del Hilo es
realizar varias operaciones simultáneamente. Cada una de estas operaciones puede ser diseñado como
un hilo separado de la lógica. La mayoría de las operaciones pasa un tiempo en estado de inactividad,
cuando una operación está a la espera de que otra culmine (por ejemplo, a la espera de una respuesta
de un servidor Web o en espera de un recurso para que se disponga). Con un Hilo, puede hacer que
el procesador o los procesadores de una máquina puedan continuar haciendo trabajos durante ese
tiempo (simultáneamente).

Se pueden utilizar programas multiproceso gracias a una característica del sistema operativo llamada
multitarea, que simula la capacidad de ejecutar varias aplicaciones a la vez. Aunque la mayoría de los
equipos disponen de un único procesador, los sistemas operativos modernos dividen el tiempo de
proceso en varias partes de código ejecutable, denominados subprocesos, para poder ofrecer así la
función multitarea.

Ejemplo – Inicial, Trabajando con HILOS

Crear una aplicación de Consola en la Cual, se pueda ejecutar 3 hilos a la ves (que cada uno de ellos
representaría un proceso), el ejercicio permitirá la ejecución de los 3 hilos en forma simultaneas.

Imports System
Imports [Link]
Imports [Link]
Imports [Link]
Module Module1
Sub Main()
Dim counter As Integer
Dim newThread As Thread
Dim threadMethod As New ThreadStart _
(AddressOf DoWork)
For counter = 1 To 3
[Link](“Inicializando Hilos : {0}”, counter)
newThread = New Thread(threadMethod)
[Link] = counter : [Link]()
Next
[Link]()
End Sub
Sub DoWork()
Dim counter As Integer
For counter = 1 To 10
[Link](“Hilo {0}: Secuencial {1}”, _
[Link], counter)
[Link](1)
Next
End Sub
End Module

El Codigo del ejemplo demuestra cómo trabajar tres hilos nuevos usando al delegado de ThreadStart.
En este ejemplo, el método de DoWork es ejecutado usando un hilo nuevo cada vez. Cada hilo escribe
la información sobre sí mismo a la consola y después iteractua 10 veces en un lazo. El método de
DoWork no acepta ningun parámetros para modificar su comportamiento para requisitos particulares.
176 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

La clase Thread
La clase Thread permite crear hilos de ejecución (subprocesos) y controlar su ejecución además
de dar prioridad a los subprocesos conocer en todo momento su estado. Los subprocesos o hilos
de ejecución son independientes entre sí, lo que permite que se ejecuten en simultáneo y además
realicen diferentes tareas.

Los siguientes son miembros de la clase Thread:

- Constructor
- Propiedades públicas
- Métodos públicos
- Métodos protegidos

Constructores públicos
Thread (Constructor) Inicializa una nueva instancia de la clase Thread.
Compatible con .NET Compact Framework.

Propiedades públicas

ApartmentState Obtiene o establece el estado de apartamento de

este subproceso.
CurrentContext Obtiene el contexto actual donde se está
ejecutando el subproceso.
CurrentCulture Obtiene o establece la referencia cultural del
subproceso actual.
CurrentPrincipal Obtiene o establece el principal del subproceso
actual (de la seguridad basada en funciones).
CurrentThread Obtiene el subproceso actualmente en ejecución.
Compatible con .NET Compact Framework.
CurrentUICulture Obtiene o establece la referencia cultural actual
utilizada por el administrador de recursos para
buscar recursos específicos de la referencia cultural
en tiempo de ejecución.
IsAlive Obtiene un valor que indica el estado de ejecución
del subproceso actual.
IsBackground Obtiene o establece un valor que indica si un
subproceso es o no un subproceso en segundo
plano.
IsThreadPoolThread Obtiene un valor que indica si un subproceso
pertenece al grupo de subprocesos administrados
o no.
Name Obtiene o establece el nombre del subproceso.
Priority Obtiene o establece un valor que indica la prioridad
Compatible con .NET Compact Framework. de programación de un subproceso.
ThreadState Obtiene un valor que contiene los estados del
subproceso actual.
 Capítulo 5: Menus, Forms Avanzados e Hilos 177

Métodos públicos

Abort Sobrecargado. Inicia una excepción ThreadAbortException

en el subproceso en el que se invoca, para iniciar el
proceso de finalización del subproceso. Normalmente,
una llamada a este método finaliza el subproceso.
AllocateDataSlot Compatible con Asigna una ranura de datos sin nombre en todos los
.NET Compact Framework. subprocesos.
AllocateNamedDataSlot Compatible Asigna una ranura de datos con nombre en todos los
con .NET Compact Framework. subprocesos.
Equals (se hereda de Object) Sobrecargado. Determina si dos instancias de Object son
Compatible con .NET Compact iguales.
Framework.
FreeNamedDataSlot Elimina la asociación entre un nombre y una ranura, en
Compatible con .NET Compact todos los subprocesos del proceso.
Framework.
GetData Recupera el valor de la posición especificada en el
Compatible con .NET Compact subproceso actual, dentro del dominio actual del
Framework. subproceso actual.
GetDomain Devuelve el dominio actual en el que se está ejecutando
el subproceso actual.
GetDomainID Devuelve un identificador único del dominio de la
aplicación.
GetHashCode (se hereda de Object) Sirve como función hash para un tipo concreto, apropiado
Compatible con .NET Compact para su utilización en algoritmos de hash y estructuras de
Framework. datos como las tablas hash.
GetNamedDataSlot Compatible con Busca una ranura de datos con nombre.
.NET Compact Framework.
GetType (se hereda de Object) Obtiene el objeto Type de la instancia actual.
Compatible con .NET Compact
Framework.
Interrupt Interrumpe un subproceso que se encuentra en estado de
subproceso WaitSleepJoin.
Join Sobrecargado. Bloquea el subproceso de llamada hasta
que termina un subproceso.
MemoryBarrier Sincroniza la memoria. En realidad, vuelca el contenido
de la memoria caché en la memoria principal, para el
procesador que ejecuta el subproceso actual.
ResetAbort Anula un método Abort solicitado para el subproceso
actual.
Resume Reanuda el subproceso que ha sido suspendido.
SetData Establece los datos de la ranura especificada en el
Compatible con .NET Compact subproceso actualmente en ejecución, para el dominio
Framework. actual de dicho subproceso.
178 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Sleep Sobrecargado. Bloquea el subproceso actual durante el

Compatible con .NET Compact número de milisegundos especificado.
Framework.
SpinWait Hace que un subproceso espere durante el período de
tiempo definido por el parámetro iterations.
Start Hace que el sistema operativo cambie el estado de la
Compatible con .NET Compact instancia actual a [Link].
Framework.
Suspend Suspende el subproceso y, si éste ya se ha suspendido, no
tiene efecto alguno.
ToString (se hereda de Object) Devuelve un objeto String que representa al objeto Object
Compatible con .NET Compact actual.
Framework.
VolatileRead Sobrecargado. Lee el valor de un campo. El valor es el
último que haya escrito cualquier procesador de un
equipo, independientemente del número de procesadores
y del estado de la caché del procesador.
VolatileWrite Sobrecargado. Escribe inmediatamente un valor en un
campo, de manera que el valor sea visible para todos los
procesadores del equipo.

Métodos protegidos

Finalize Reemplazado. Libera los recursos mantenidos por esta

Compatible con .NET Compact instancia. En C# y C++, los finalizadores se expresan
Framework. mediante la sintaxis del destructor.
MemberwiseClone (se hereda Crea una copia superficial del objeto Object actual.
de Object) Compatible con .NET
Compact Framework.

La clase del hilo maneja un hilo y controla su comportamiento de programación. los delegados del
ayudante asociados a la clase del hilo son:
- ThreadStart
- ParameterizedThreadStart

El .NET Framework proporciona varias clases en el namespace de [Link] que le ayuden

a manejar un hilo. La clase primaria usada para manejar los hilos es directamente la clase Thread.
Usted puede utilizar esta clase programable para controlar el comportamiento de un hilo. Aunque
usted puede fijar prioridades de hilos durante tiempo de pasada usando a encargado de la tarea(Task
Manager), la clase Thread proporciona control sobre un hilo, más allá de la asignación de la prioridad,
sin la necesidad de la intervención del usuario. Además, usted puede utilizar la clase Thread para crear,
destruir, y para detenerse los Hilos

Los delegados ayudan para implementar la clase Thread en ejecución. Para crear un hilo, usted
necesita utilizar a un delegado ayudante. Hay dos delegados ayudante asociados a la clase Thread, El
ThreadStart y el ParameterizedThreadStart.
 Capítulo 5: Menus, Forms Avanzados e Hilos 179

Ambos delegados señalan a un método que usted pueda utilizar como punto de partida para el hilo.
Usando al delegado de ParameterizedThreadStart, usted puede pasar un objeto que modifique el
comportamiento para requisitos particulares del método al comienzo. Sin embargo, el delegado de
ThreadStart no proporciona esta funcionalidad.

Tabla Propiedades Hilos

Character Description
IsAlive Contiene el valor True si un subproceso se encuentra activo.
IsBackground Obtiene o establece un valor booleano que indica si un subproceso es o
debería ser un subproceso en segundo plano. Los subprocesos en segundo
plano son como los subprocesos en primer plano, excepto que no impiden
que finalice un proceso. Una vez que concluyen todos los subprocesos en
primer plano de un proceso, Common Language Runtime llama al método
Abort de los subprocesos en segundo plano activos para finalizar dicho
proceso.
Name Obtiene o establece el nombre de un subproceso. Se utiliza principalmente
para descubrir subprocesos independientes durante la depuración.
Priority Obtiene o establece un valor que utiliza el sistema operativo para dar
prioridad en la programación de subprocesos.
ApartmentState Obtiene o establece el modelo de subprocesamiento que utiliza un
subproceso específico. Los modelos de subprocesamiento resultan útiles
cuando un subproceso llama a código no administrado.
ThreadState Contiene un valor que describe el estado o estados de un subproceso.

Table Metodos Hilos

Nombre Descripcion
Start Inicia la ejecución de un subproceso.
Sleep Detiene un subproceso durante un tiempo determinado.
Suspend Interrumpe un subproceso cuando alcanza un punto seguro.
Abort Detiene un subproceso cuando alcanza un punto seguro.
Resume Reinicia un subproceso suspendido.
Join Deja en espera un subproceso hasta que finaliza otro subproceso diferente.
Si se utiliza con un valor de tiempo de espera, este método devuelve True
cuando el subproceso finaliza en el tiempo asignado.

Ejemplo con Hilos, Parametrizacion de los Hilos

Construir otra aplicación de consola, ahí generamos un nuevo modulo, El código ejemplo que se
muestra nos indica como trabajar tres hilos nuevos usando al delegado de ParameterizedThreadStart.
En este ejemplo, el método de DoWork es ejecutado usando un hilo nuevo cada vez. Cada hilo escribe
la información sobre sí mismo a la consola y este interactúa en un lazo determinado por el parámetro
ingresado en el Metodo Start. El método de DoWork acepta un parámetro para modificar el número
de interacciones del método. Usted puede pasar un parámetro en el método de DoWork cuando un
hilo nuevo lo llama solamente usando al delegado de ParameterizedThreadStart.
180 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Imports [Link]
Module Module2
Sub Main()
Dim counter As Integer
Dim newThread As Thread
Dim threadMethod As New ParameterizedThreadStart _
(AddressOf DoWork)
For counter = 1 To 3
[Link](“Inicio del Hilo {0}”, _
counter)
newThread = New Thread(threadMethod)
[Link] = counter
[Link](5)
Next
[Link]()

End Sub
Sub DoWork(ByVal iterations As Object)
Dim maxIterations As Integer = CType(iterations, Integer)
Dim counter As Integer
For counter = 1 To maxIterations
[Link](“Hilos {0}: Secuencia {1}”, _
[Link], counter)
[Link](1)
Next
End Sub
End Module

Ejemplo de Hilos, Trabajando con una Aplicacion Windows

Se pide realizar un formulario que permita utilizar el control BackgroundWorker, que permite poder
manejar la ejecución de hilos

El script es el siguiente, nos conectaremos a la base de datos de Sql Server 2008 la cual es
AdventureWorks, con la tabla [Link]
 Capítulo 5: Menus, Forms Avanzados e Hilos 181

Private Sub Button1_Click(ByVal sender As [Link], ByVal e As [Link])

Handles [Link]
[Link]()
[Link] = True: [Link] = True
End Sub
Private Sub BackgroundWorker1_DoWork(ByVal sender As [Link], ByVal e As
[Link]) Handles [Link]
Dim strcn As String = “data Source=.;Initial Catalog=Northwind;uid=sa;pwd=;”
Dim cnSQL As New [Link](strCn)
[Link]()
[Link](50)
[Link](2000) ‘ Para simular tiempo de espera
Dim adp As New [Link](“Select * From Employees”, cnSQL)
Dim dsTemp As New DataSet
[Link](dsTemp, “Instructores”) : [Link] = dsTemp
End Sub
Private Sub BackgroundWorker1_ProgressChanged(ByVal sender As Object, ByVal e
As [Link]) Handles BackgroundWorker1.
ProgressChanged
[Link] = [Link]
End Sub
Private Sub BackgroundWorker1_RunWorkerCompleted(ByVal sender As Object, ByVal e
As [Link]) Handles BackgroundWorker1.
RunWorkerCompleted
[Link] = CType([Link], DataSet)
[Link] = “Instructores”
MsgBox(“Metodo Terminado”) : [Link] = False
[Link] = False
End Sub

TIPOS DE FORMAS DE TRABAJAR LOS HILOS

Sincrona
el proceso de manejar el acceso a los recursos que son compartidos por los hilos múltiples se
llama sincronización. La sincronización incluye los mecanismos de locking, signaling y operaciones
interlocked.

Locking
Se puede utilizar los mecanismos de fijación para trabar un recurso para controlar el acceso de hilos
a ese recurso. Usted puede configurar los Bloqueos de modo que solamente un solo hilo pueda
tener acceso al recurso. Hay varios tipos de Bloqueos. Los mas comunes incluyen los bloqueos
exclusivos y compartidas. El .NET Framework proporciona varias clases que usted pueda utilizar para
trabar recursos. Sin embargo, el método más simple para trabar un recurso compartido es utilizar la
declaración SyncLock en Visual Basic o Lock en C#.

Signaling
Los hilos pueden supervisar un recurso antes de procurar colocar un Bloqueo en el recurso para
determinarse si el recurso es trabado ya por otro hilo. Si un recurso es ya Bloqueado, un hilo puede
esperar y supervisar el recurso en los intervalos hasta que el hilo pueda trabar el recurso. Además, un
hilo que ha trabado un recurso notifica a los otros hilos cuando se acaba con el recurso, de modo que
el hilo de rosca siguiente en la coleta pueda asegurar un bloqueo en el recurso. Cuando el hilo notifica
otro hilo sobre el estado de la cerradura de un recurso, se llama el proceso Signaling.
182 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Interlocking
La sincronización incluye algunas operaciones enlazadas que usted pueda utilizar para realizar
operaciones simples en una posición de memoria compartida o una variable. Usted puede realizar
operaciones simples en una variable, tal como incremento de ella o asignarle un nuevo valor numérico.
Sin embargo, el trabajo con la clase enlazada para realizar estas operaciones simples requiere
absolutamente una codificación compleja.

Asincrona
En la programación asincrónica, las llamadas a varios métodos se hacen de una manera paralela donde
una llamada del método no espera el otro método para terminar antes de que la ejecución del uso
continúe.

Para entender la diferencia entre la programación síncrona y asincrónica, considere los comandos
ficticios siguientes: Comando1, Comando 2, Comando 3, y Comando 4. Comando1 representa el
programa principal donde la ejecución comienza.Command2 es una llamada a un método externo
que pueda tomar un cierto tiempo para terminar. Si una llamada síncrona se hace a Command2, el
necesitara esperar hasta que recibe un descanso o un valor de vuelta de Command2 para ejecutar
Command3.

Si se hace la llamada usando la programación asincrónica, el método externo se ejecuta en un hilo

separado, que permite que Command3 sea ejecutado sin esperar una vuelta. En este caso, el resultado
para Command2 no será sabido hasta los extremos de hilo seran separados.

Por lo tanto, usted no puede utilizar llamadas asincrónicas cuando el resultado de un método se
requiere antes de ejecutar declaraciones subsecuentes.

El ocuparse de una llamada asincrónica usted puede ocuparse de cuatro maneras:

• Llamando EndInvoke del hilo principal.
• Usando el método de WaitHandle para signaling.
• Comprobando la característica de el IsCompleted para saber si el objeto volvió por el método de
BeginInvoke. Usando un servicio repetido al llamar al delegado BeginInvoke.

La puesta en práctica del interfaz de los Delegados IAsyncResult y AsyncCallback las demostraciones
siguientes del ejemplo del código cómo poner al interfaz de IAsyncResult y al delegado de AsyncCallback
en ejecución.

Formulario Principal para los ejemplos de HILOS

Ejemplo: Vamos a crear un formulario con varias fichas como se
aprecia en la figura:

Para esto vamos a utilizar el control TabControl:

 Capítulo 5: Menus, Forms Avanzados e Hilos 183

El cual posee varios tabuladores.

El que va a personalizarse de la siguiente manera:

Ahora adicionamos los TAB al Formulario

184 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Luego realizamos la modificación del caso para cada una de las opciones

Ahora, vamos a desarrollar en una aplicación Windows de ejemplo, algunas las opciones mencionadas
en los TAB.

Ejemplo Inicial del Formulario – 1er Tabulador

En el primer tabulador a agregar un Botón (Button) cuyo nombre será bntIniciar y un Cuadro de Lista
(List Box) con nombre lstElementos.

El código del botón btnIniciar y del primer tabulador es el siguiente:

Imports [Link]
Public Class Form1
Inherits [Link]
Private lstHilo As New ListBox
Private oHilo01 As Thread
Private Sub cmdIniciar_Click(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
Dim i As Integer
Dim strElemento As String
‘ Crea el objeto oHilo_01 en base a la clase Thread
‘ y se indica que el proceso a ejecutar es Hilo_01
oHilo01 = New Thread(AddressOf Hilo_01)
‘ Se inicia el proceso
[Link]()
For i = 0 To [Link] - 1
strElemento = [Link](i).ToString()
 Capítulo 5: Menus, Forms Avanzados e Hilos 185

[Link](strElemento)
Next
End Sub
Private Sub Hilo_01()
Dim i, iNro As Integer
Dim strElemento As String
For iNro = 1 To 10
strElemento = “Elemento “ & iNro : [Link](strElemento)
For i = 1 To 10000
Next
Next
[Link]()
End Sub
End Class

En el primer tabulador se ha implementado un solo hilo de ejecución el que rellenará una variable de
tipo ListBox de nombre lstHilo con los valores siguientes:
Elemento 1
Elemento 2
Elemento 3
Elemento 4
Elemento 5
Elemento 6
Elemento 7
Elemento 8
Elemento 9
Elemento 10

Finalmente se aborta el hilo mediante el método Abort( ) del objeto tipo Thread al que denominamos
oHilo.

Con lo que se aprecia lo siguiente:

186 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ejemplo del segundo tabulador (Funcionalidad)

Que consiste en ejecutar dos hilos y detenerlos al mismo tiempo. Para ello usaremos tres botones:
bntIniciar2, bntAbortar1 y bntAbortar1, el primero para iniciar los dos hilos: oHilo01 y oHilo02 y los
otros para abortar la ejecución de los hilos.

Ahora vamos a realizar el siguiente código:

Imports [Link]
Public Class Form1
Inherits [Link]
Private lstHilo As New ListBox
Private oHilo01, oHilo02 As Thread
Private Sub cmdIniciar_Click(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
Dim i As Integer
Dim strElemento As String
‘ Se crea el objeto oHilo_01 en base a la clase Thread
‘ y se le indica que el proceso a ejecutar es Hilo_01
oHilo01 = New Thread(AddressOf Hilo_01)
‘ Se inicia el proceso
[Link]()
For i = 0 To [Link] - 1
strElemento = [Link](i).ToString()
[Link](strElemento)
Next
End Sub
Private Sub bntIniciar2_Click(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
‘ Se crea el objeto oHilo_01 en base a la clase Thread
‘ y se le indica que el proceso a ejecutar es Hilo_01
oHilo01 = New Thread(AddressOf Hilo_01)
oHilo02 = New Thread(AddressOf Hilo_02)
‘ Se inicia el proceso
[Link]()
[Link]()
End Sub

Ahora realizaremos el proceso de los HILOS

Private Sub Hilo_01()

Dim i, iNro As Integer
Dim strElemento As String
For iNro = 1 To 100
strElemento = “Hilo1 “ & iNro
[Link](strElemento)
‘ Pausa
For i = 1 To 10000000
 Capítulo 5: Menus, Forms Avanzados e Hilos 187

Next
Next
End Sub
Private Sub Hilo_02()
Dim i, iNro As Integer
Dim strElemento As String
For iNro = 1 To 100
strElemento = “Hilo2 “ & iNro
[Link](strElemento)
‘ Pausa
For i = 1 To 10000000
Next
Next
End Sub
Private Sub btnAbortar01_Click(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
Dim i As Integer
Dim strElemento As String
[Link]()
For i = 0 To [Link] - 1
MsgBox(i)
strElemento = [Link](i).ToString()
[Link](strElemento)
Next
End Sub
Private Sub btnAbortar02_Click(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
Dim i As Integer
Dim strElemento As String
[Link]()
For i = 0 To [Link] - 1
MsgBox(i)
strElemento = [Link](i).ToString()
[Link](strElemento)
Next
End Sub
End Class

En éste ejemplo se puede abortar cada uno de los hilos en diferente momento. Sin embargo lo que
ocurre es que repetimos el valor de los elementos y los duplicamos.

Ejemplo de Trabajar con 10 HILOS a la vez

A continuación se implementarán 10 hilos de ejecución y se abortarán los 10 en forma simultánea y
evitar así alguna duplicidad, esto se realizará en el tercer tabulador.

Para ello se usará únicamente una lista LstElementos3 y dos botones el primero es bntIniciar3 y el
segundo botón bntAbortar3. En la figura que viene a continuación se aprecia lo que se necesita:
188 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

El código es el siguiente:

Imports [Link]

Public Class Form1

Inherits [Link]
Private lstHilo As New ListBox
Private oHilo01, oHilo02, oHilo03, oHilo04, oHilo05 As Thread
Private oHilo06, oHilo07, oHilo08, oHilo09, oHilo10 As Thread
Private Sub cmdIniciar_Click(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
Dim i As Integer
Dim strElemento As String
‘ Se crea el objeto oHilo_01 en base a la clase Thread
‘ y se le indica que el proceso a ejecutar es Hilo_01
oHilo01 = New Thread(AddressOf Hilo_01)
‘ Se inicia el proceso
[Link]()
For i = 0 To [Link] - 1
‘MsgBox(i)
strElemento = [Link](i).ToString()
[Link](strElemento)
Next
End Sub

Private Sub bntIniciar2_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
‘ Se crea el objeto oHilo_01 en base a la clase Thread
‘ y se le indica que el proceso a ejecutar es Hilo_01
oHilo01 = New Thread(AddressOf Hilo_01)
oHilo02 = New Thread(AddressOf Hilo_02)
‘ Se inicia el proceso
[Link]()
[Link]()
End Sub
Private Sub btnAbortar01_Click(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
Dim i As Integer
Dim strElemento As String
[Link]()
For i = 0 To [Link] - 1
MsgBox(i)
strElemento = [Link](i).ToString()
[Link](strElemento)
Next
End Sub
Private Sub btnAbortar02_Click(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
Dim i As Integer
Dim strElemento As String
[Link]()
For i = 0 To [Link] - 1
MsgBox(i)
strElemento = [Link](i).ToString()
[Link](strElemento)
Next
End Sub
Private Sub btnIniciar3_Click(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
‘ Se crean los objetos Hilo en base a la clase Thread
oHilo01 = New Thread(AddressOf Hilo_01)
oHilo02 = New Thread(AddressOf Hilo_02)
 Capítulo 5: Menus, Forms Avanzados e Hilos 189

oHilo03 = New Thread(AddressOf Hilo_03)

oHilo04 = New Thread(AddressOf Hilo_04)
oHilo05 = New Thread(AddressOf Hilo_05)
oHilo06 = New Thread(AddressOf Hilo_06)
oHilo07 = New Thread(AddressOf Hilo_07)
oHilo08 = New Thread(AddressOf Hilo_08)
oHilo09 = New Thread(AddressOf Hilo_09)
oHilo10 = New Thread(AddressOf Hilo_10)
‘ Se inician los procesos
[Link]() : [Link]() : [Link]()
[Link](): [Link](): [Link]()
[Link](): [Link](): [Link]()
[Link]()
End Sub

Private Sub Hilo_01()

Dim i, iNro As Integer
Dim strElemento As String
For iNro = 1 To 100
strElemento = “Hilo1 “ & iNro
[Link](strElemento)
‘ Pausa
For i = 1 To 10000000
Next
Next
End Sub
Private Sub Hilo_02()
Dim i, iNro As Integer
Dim strElemento As String
For iNro = 1 To 100
strElemento = “Hilo2 “ & iNro
[Link](strElemento)
For i = 1 To 10000000
Next
Next
End Sub
Private Sub Hilo_03()
Dim i, iNro As Integer
Dim strElemento As String
For iNro = 1 To 100
strElemento = “Hilo3 “ & iNro
[Link](strElemento)
For i = 1 To 10000000
Next
Next
End Sub
Private Sub Hilo_04()
Dim i, iNro As Integer
Dim strElemento As String
For iNro = 1 To 100
strElemento = “Hilo4 “ & iNro
[Link](strElemento)
For i = 1 To 10000000
Next
Next
End Sub
Private Sub Hilo_05()
Dim i, iNro As Integer
Dim strElemento As String
For iNro = 1 To 100
strElemento = “Hilo5 “ & iNro
[Link](strElemento)
For i = 1 To 10000000
Next
Next
End Sub
190 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Private Sub Hilo_06()

Dim i, iNro As Integer
Dim strElemento As String
For iNro = 1 To 100
strElemento = “Hilo6 “ & iNro
[Link](strElemento)
For i = 1 To 10000000
Next
Next
End Sub
Private Sub Hilo_07()
Dim i, iNro As Integer
Dim strElemento As String
For iNro = 1 To 100
strElemento = “Hilo7 “ & iNro
[Link](strElemento)
For i = 1 To 10000000
Next
Next
End Sub
Private Sub Hilo_08()
Dim i, iNro As Integer
Dim strElemento As String
For iNro = 1 To 100
strElemento = “Hilo8 “ & iNro
[Link](strElemento)
For i = 1 To 10000000
Next
Next
End Sub
Private Sub Hilo_09()
Dim i, iNro As Integer
Dim strElemento As String
For iNro = 1 To 100
strElemento = “Hilo9 “ & iNro
[Link](strElemento)
For i = 1 To 10000000
Next
Next
End Sub
Private Sub Hilo_10()
Dim i, iNro As Integer
Dim strElemento As String
For iNro = 1 To 100
strElemento = “Hilo10 “ & iNro
[Link](strElemento)
For i = 1 To 10000000
Next
Next
End Sub

Private Sub btnAbortar3_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Dim i As Integer
Dim strElemento As String
[Link]()
[Link]()
[Link]()
[Link]()
[Link]()
 Capítulo 5: Menus, Forms Avanzados e Hilos 191

[Link]()
[Link]()
[Link]()
[Link]()
[Link]()

For i = 0 To [Link] - 1
strElemento = [Link](i).ToString()
[Link](strElemento)
Next
End Sub
End Class

Los resultados de abortar la ejecución de los hilos es el siguiente:

Con esto hemos finalizado el ejemplo.

Ejemplo de Hilos realizando varios procesos

Ejemplo de Manejo de Hilos, en cual se ejecutaran 2 procesos a la vez, uno es una descarga y el otro
es una serie fibonacci, mientras que no se marque el check en el control que dice thread, el proceso
que se está ejecutando bloqueara a toda la ventana, en caso de que seleccione ese control thread, este
permitirá poder ejecutar los 2 procesos a la vez.
192 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Valores de las propiedades de los controles

Control Propiedades Valor

Textbox (name) txtNumero
Textbox (name) Textbox1
Multiline True
Checkbox (name) chkthread
Button (name) btnCalcular
Text Calcular
Button (name) Button1
text Descargar

Ahora empezaremos a codificar los eventos:

Imports [Link]
Public Class frmTestHilos
Private objHilo As Thread
Private ObjHiloDescarga As Thread

Private Sub btnCalcular_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
If [Link] Then
‘Se instancia el hilo e indicamos el procedimiento a ejecutar
objHilo = New Thread(AddressOf Calcular)
[Link]()
Else
Calcular()
End If
End Sub

Ahora realizaremos algunas subrutinas que se utilizaran en el formulario

Public Sub Calcular()

Dim lngValue As Long
lngValue = Fibonacci([Link])
[Link](“El resultado es “ & lngValue, “Exito”)
End Sub

Public Function Fibonacci(ByVal intNum As Integer) As Long

If intNum < 0 OrElse intNum > 80 Then
Return 0
End If
Dim lonResul As Long = 0
If intNum < 2 Then
lonResul = 1
Else
lonResul = Fibonacci(intNum - 1) + Fibonacci(intNum - 2)
End If
Return lonResul
End Function
Private Sub descarga()
[Link](“[Link]
e 8228582-8113-40d2-aa7b-2dfd2f73ebdf / T a l l e r _ M S D N _ M i g r a c i o n _ V B _ N E T . p p t ” ,
“[Link]”)
[Link](“Descarga Completa”)
End Sub
Private Sub Button1_Click(ByVal sender As [Link], ByVal e As [Link])
Handles [Link]
ObjHiloDescarga = New Thread(AddressOf descarga)
[Link]()
End Sub
 CAPÍTULO

6
Trabajando con Archivos y
Gráficos en Visual Studio 2010
 CAPÍTULO

6
Trabajando con Archivos y
Gráficos en Visual Studio 2010

MANEJO DE ARCHIVOS Y DIRECTORIOS

¿Que son la clase FileSystem?
Se encuentra dentro del namespace [Link], son un conjunto de clases se utiliza para navegar y
manipular archivos, directorios y unidades. El sistema de archivos de clases se separan en dos tipos de
clases: la información y utilidad.

La mayoría de las clases de información se derivan de la clase base FileSystemInfo. Estas clases expone
todos los sistema de información sobre los objetos del sistema de archivos-concretamente, los archivos,
directorios y unidades. Estas clases son FileInfo y DirectoryInfo.

Además, la clase DriveInfo representa una unidad en el sistema de Archivos, pero a pesar de que sigue
siendo una clase de información, no se deriva de la clase FileSystemInfo porque no comparten el tipo
de comportamiento (por ejemplo, puede borrar archivos y carpetas, pero no Drives).

Cómo obtener información sobre un archivo

Para obtener información sobre un archivo específico, siga los siguientes pasos de construccion del
script:
• Crear una nueva objeto fileInfo para utilizar la direccion del Archivo.
• Acceda a las propiedades del Objeto fileInfo.

Por ejemplo, usted puede verificar si existe archivos llamando al Objeto fileInfo , como se muestra en
el siguiente código:

Sub Main
‘Verificar si existe un Archivo
Dim ourFile As FileInfo = New FileInfo(“c:\[Link]”)
‘En caso de que no existe
If [Link] Then
[Link](“Filename : {0}”, [Link])
[Link](“Path : {0}”, [Link])
End If
End Sub

Cómo copiar un archivo

Además de acceder a los datos de un Archivo el objeto FileInfo permite realizar operaciones en el
archivo. Una vez más, una vez al válida objeto FileInfo, todo lo que tiene que hacer es llamar al método
CopyTo para hacer una copia de su archivo, como el código siguiente ejemplo muestra:

‘Copia un Archivo
Dim ourFile As FileInfo = New FileInfo(“c:\[Link]”)
[Link](“c:\[Link]”)
[Link]()
196 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Cómo enumerar archivos en un directorio

Acceder a los archivos en un directorio es muy similar a acceder a la información del archivo. Los pasos
siguientes muestran la forma de enumerar los archivos en un directorio:
• Crear una validación del objeto DirectoryInfo mediante el uso de la ruta al directorio.
• Llame al método GetFiles para enumerar los archivos en el directorio.

El siguiente código de ejemplo muestra cómo llevar a cabo esta tarea:

‘Como verificar todos los archivos que se encuentran en el directorio especifico

Dim BuscarDir As DirectoryInfo = New DirectoryInfo(“c:\windows”)
[Link](“Directory: {0}”, [Link])
Dim file As FileInfo
For Each file In [Link]()
[Link](“File: {0}”, [Link])
Next
[Link]()

Cómo enumerar las unidades

Siga este procedimiento para acceder a las unidades en un sistema:
• Llame al Método estático GetDrives de la clase DriveInfo.
• Genere un repetición a través de un array del objeto DriveInfo devueltos por GetDrives.

El código siguiente ejemplo ilustra este proceso:

Dim drives() As DriveInfo = [Link]()

Dim drive As DriveInfo

For Each drive In drives
[Link](“Drive: {0}”, [Link])
[Link](“Type: {0}”, [Link])
Next

Lectura y Escritura sobre Archivos

Cómo leer de un archivo
Abrir un archivo es bastante frecuente. Al abrir un archivo para leer su contenido, se utiliza el Miembro
de enumeración [Link] para especificar un archivo existente, así como [Link] para
obtener acceso de sólo lectura al expediente, como se ha visto en este código de ejemplo:

Sub Main()
Dim theFile As FileStream = _
[Link](“C:\[Link]”, [Link], [Link])
Dim rdr As StreamReader = New StreamReader(theFile)
[Link]([Link]())
[Link]()
[Link]()
[Link]()
End Sub

La clase StreamReader se destina a leer un stream como una cadena, no como una serie de bytes. De
esta manera, los métodos del StreamReader generan la devolución de todos los datos de retorno, ya
sea cadenas o arreglos de cadenas.
 Capítulo 6: Trabajando con Archivos y Gráficos en Visual Studio 2010 197

La clase de archivos soporta algunos métodos adicionales para que sea más sencillo para abrir un
archivo para lectura. En el ejemplo anterior, usted ha creado una FileStream y luego creó una nueva
StreamReader. El archivo de clase apoya la creación de un StreamReader directamente con el método
OpenText, como se ve en este fragmento de código:

Dim rdr As StreamReader = [Link](“C:\[Link]”)

[Link]([Link]())
[Link]()

Como Escribir en un Archivo

Antes de poder escribir a un archivo, usted tiene que abrir el archivo para la escritura. Este proceso es
similar a abrir un archivo para lectura. Por ejemplo, puede abrir un archivo para escribir tal como se
muestra aquí:

‘Para Poder escribir Información sobre un Archivo

Dim theFile as FileStream
theFile = [Link](“c:\[Link]”)
Dim writer As StreamWriter = New StreamWriter(theFile)
[Link](“Hola, Como estan”)
[Link](“Bienvenidos a Visual Studio 2008”)
[Link]()
[Link]()
[Link]()

Puede utilizar la StreamWriter para escribir texto directamente en su nuevo archivo. Este patrón es
muy similar a la pauta para la lectura de un archivo. Además, como se ha demostrado anteriormente
para la lectura, la clase de archivos apoya la creación de un objeto StreamWriter directamente con el
método CreateText:

Dim ArchEscribe as StreamWriter = [Link](“c:\[Link]”)

[Link](“Una Linea Mas de Escritura”)
[Link]()

El archivo de clase también soporta el metodo WriteAllText el cual escribe una cadena en un nuevo
archivo, tal y como se muestra aquí:

[Link](“c:\[Link]”,”Hola Como estas”)

Este proceso es sencillo, pero hay momentos en que necesita escribir en un archivo existente. El escribir
en un archivo existente es similar, excepto para la forma en que usted abre el archivo. Para abrir un
archivo para escritura, se debe usar el archivo de clase del método Open, pero especificar que desea
escribir en el stream que es retornado, como se muestra en este ejemplo:

Dim TheArch as FileStream

TheArch = [Link](“c:\[Link]”,[Link],[Link])

El archivo tiene el método OpenWrite que es un atajo para lograr esto y simplifica la apertura de
los archivos existentes para la escritura. En lugar de llamar al método Open de la clase de archivo y
especificar que desea que lo abra a la escritura, puede simplemente usar el código como este:

theArch = [Link](“c:\[Link]”)
198 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

OTRA FORMA DE TRABAJAR CON ARCHIVOS

Abriendo un Archivo de Entrada y Salida:

FileOpen (FileNumber, FileName, Mode, Access)

Parámetros para Abrir Archivos:

FileNumber
Este parámetro es requerido. Cualquier número de archivo válido. La función FreeFile se utiliza para
obtener el siguiente número de archivo disponible.

FileName
Este parámetro es requerido. Expresión de tipo String que especifica un nombre de archivo (puede
incluir el directorio o la carpeta y la unidad).

Mode
Este parámetro es requerido, que especifica el modo de archivo: Append, Binary, Input, Output o
Random.
Random: El archivo contiene registros de una estructura.
Output: Cualquier proceso puede leer o escribir en él.
Binary: Ningún otro proceso podrá leerlo

Access
Este parámetro es opcional. Palabra clave que especifica las operaciones permitidas en el archivo
abierto.
Read
Write
ReadWrite

Obs: El valor predeterminado es ReadWrite.

Escribiendo en un Archivo:

FilePut (FileNumber, Value)

Parámetros para escribir en un archivo:

FileNumber
Este parámetro es requerido, cualquier número de archivo válido.

Value
Este parámetro es requerido, nombre válido de variable que contiene los datos escritos en disco.

Ejemplo:
 Capítulo 6: Trabajando con Archivos y Gráficos en Visual Studio 2010 199

Leyendo un Archivo:

FileGet (FileNumber, Value, RecordNember)

Lee datos de un archivo de disco abierto y los coloca en una variable.

Parámetros para leer el contenido de un archivo:

FileNumber
Este parámetro es requerido, cualquier número de archivo válido.

Value
Este parámetro es requerido, nombre de variable válido en el que se leen los datos.

RecordNumber
Este parámetro es opcional. Número de registro (archivos en modo Random) o número de byte
(archivos en modo Binary) desde el que comienza la lectura.

Ejemplo:

Ejemplo – Trabajando con Archivos en una Aplicacion Windows

Se declara una variable global al formulario de tipo entero

Dim nProd As Integer

200 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ahora se empiezan agregar nombres en el listbox1, esto se ingresara desde el control de texto

Private Sub btnAgregar_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
If [Link] <> “” Then
[Link]([Link])
Else
MsgBox(“Falta Ingresarle el Producto”)
End If
[Link]()
[Link]()
End Sub

El botón btnExportar me permitirá que los archivos ingresados al Listbox1, se puedan

almacenar(importar) a un archivo tipo Texto

Private Sub btnExportar_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Dim i As Integer
Dim sruta As String
Dim SaveFile As New SaveFileDialog
[Link] = “Archivos de Texto(*.txt)|*.txt”
If [Link] = [Link] Then
sruta = [Link]
FileOpen(1, sruta, [Link])
nProd = [Link]
For i = 0 To nProd - 1
Dim sProducto As String = [Link](i)
sProducto += Space(30 - Len(sProducto))
FilePut(1, sProducto)
Next
FileClose(1)
MsgBox(“Archivo exportado con Exito”)
Else
MsgBox(“Falta Ingresar el Nombre del Archivo.....!!!”)
End If
End Sub

Ahora empecemos a codificar el botón btnImportar, el cual nos va a permitir poder de recuperar los
datos guardados en el Archivo

Private Sub btnImportar_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Dim i As Integer
Dim sProducto As New String(“ “, 30)
Dim sRuta As String = “”
Dim OpenFile As New OpenFileDialog
[Link] = “Archivos de Texto(*.txt)|*.txt”
If [Link] = [Link] Then
sRuta = [Link]
End If
FileOpen(1, sRuta, [Link])
For i = 0 To nProd
FileGet(1, sProducto)
[Link](sProducto)
Next
FileClose(1)
End Sub
 Capítulo 6: Trabajando con Archivos y Gráficos en Visual Studio 2010 201

La clase FileSystemWatcher
Escucha las notificaciones de cambio del sistema de archivos y provoca eventos cuando cambia un
directorio o un archivo de un directorio.

La clase FileSystemWatcher omite los caracteres en un nombre de archivo en mayúscula

En Microsoft Visual Studio . NET, puede utilizar los cambios de monitor de clase FileSystemWatcher
realizados en el sistema de archivos. Cuando un archivo se cambia, se crea o se elimina, la clase
FileSystemWatcher devuelve el nombre del archivo de letras minúsculas aunque el nombre de archivo
real contiene letras mayúsculas.

Ejemplo del FileSystemWatcher

Para resolver este problema, utilice la clase [Link] para recuperar el nombre de archivo
real. Para ello, siga estos pasos:

Este ejemplo de una aplicación de consola, Ud puede notar de lo que se trata es de poder visualizar
los cambios efectuados en un directorio Especifico, para poder hacer esto debe cargar esta aplicación
y dejarla activa mientras ud. Ejecuta los cambios.

Sub Main()
Dim watcher As FileSystemWatcher = New FileSystemWatcher()
[Link] = “c:\”

‘ Registro para los Eventos

AddHandler [Link], _
New FileSystemEventHandler(AddressOf watcher_Changed)
AddHandler [Link], _
New FileSystemEventHandler(AddressOf watcher_Changed)

‘ Inicio de Monitoreo
[Link] = True
[Link]()
End Sub

‘ Event Handler
Sub watcher_Changed(ByVal sender As Object, _
ByVal e As FileSystemEventArgs)

[Link](“Directory changed({0}): {1}”, _

[Link], [Link])

End Sub

Utilice FileSystemWatcher para inspeccionar cambios realizados en un directorio especificado. Es

posible inspeccionar cambios en archivos y subdirectorios del directorio especificado. Puede crear un
componente para inspeccionar archivos en un equipo local, una unidad de red o un equipo remoto.
202 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

CUADROS DE DIALOGO
SaveFileDialog
El componente SaveFileDialog permite a los usuarios examinar el sistema de archivos y seleccionar los
archivos que deseen guardar. El cuadro de diálogo devuelve la ruta de acceso y el nombre del archivo
que seleccionó el usuario en el cuadro de diálogo. Sin embargo, debe escribir el código para escribir
realmente los archivos en el disco.

Para mostrar esta pantalla existen dos formas:

A nivel ejecución:

Dim xFile as New SaveFileDialog

[Link]()

Y a nivel diseño:
Desde el cuadro de herramientas en Diálogos seleccionamos el control SaveFileDialog y lo soltamos en
el formulario, luego escribiríamos lo siguiente:

[Link]()

Se debe utilizar el método OpenFile del componente SaveFileDialog para guardar el archivo
seleccionado con la propiedad FileName. Este método le proporciona un objeto Stream en el que se
puede escribir. El siguiente ejemplo utiliza la enumeración para los tipos de resultados en DialogResult
para obtener el nombre del archivo y el método OpenFile para guardarlo.
 Capítulo 6: Trabajando con Archivos y Gráficos en Visual Studio 2010 203

OpenFileDialog
El componente OpenFileDialog de formularios Windows Forms es un cuadro de diálogo preconfigurado.
Es el mismo cuadro de diálogo Abrir archivo que expone el sistema operativo de Windows. Se hereda
de la clase CommonDialog.

Para mostrar esta pantalla existen dos formas:

A nivel ejecución:

Dim xFile as New OpenFileDialog

[Link]()

Y a nivel diseño:
Desde el cuadro de herramientas en Diálogos seleccionamos el control OpenFileDialog y lo soltamos
en el formulario, luego escribiríamos lo siguiente:

[Link]

Utilice este componente dentro de la aplicación para Windows como una solución sencilla para
seleccionar archivos, en lugar de configurar un cuadro de diálogo propio. Al basarse en cuadros de
diálogo estándar de Windows, creará aplicaciones cuya funcionalidad básica resultará inmediatamente
familiar para los usuarios. Tenga en cuenta, no obstante, que cuando utilice el componente
OpenFileDialog deberá escribir su propia lógica de apertura de archivos.
204 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Propiedades OpenFileDialog y SaveFileDialog

InitialDirectory - Define la carpeta inicial al momento de mostrar los controles.

Filter - Define el tipo de archivo que se listara.

FilterIndex - Especifica el default para el elemento de filtro cuando aparece la caja de dialogo.

RestoreDirectory - Si es verdadero(true), podria forzar a que se muestre el directorio presentado la

primera vez.

FileName - Especifica la ruta completa y nombre del archivo seleccionado.

ShowDialog - Muestra el control.

ColorDialog
Proporciona la selección de colores en las aplicaciones de Windows, el sistema operativo proporciona
un cuadro de diálogo común apropiado para tales tareas. El cuadro de diálogo de color se utiliza por
varias razones que permiten al usuario configurar o cambiar el color de un objeto, como el color de
fondo de un control o el color utilizado para un objeto. Se muestra por defecto, el cuadro de diálogo
de la siguiente manera:

Propiedades

Color - Permite trabajar con el [Link] para seleccionar los colores.

AllowFullOpen - Si es true permite que el usuario seleccione uno de los colores que se muestran.

ShowDialog - Muestra la caja de dialog.

La forma de utilizarlo dentro de una aplicacion es de la siguiente manera:

Private Sub Button1_Click(ByVal sender As [Link], _

ByVal e As [Link]) Handles [Link]
[Link]()
End Sub
 Capítulo 6: Trabajando con Archivos y Gráficos en Visual Studio 2010 205

En las propiedades del control se encuentra de la siguiente manera:

FontDialog
El control FontDialog representa un dialogo preconfigurado que despliega la caja de dialogo de fuente
estándar, por default la caja de dialogo muestra cajas de listas para la fuente, estilo-fuente, y tamaño,
cajas de chequeo para efectos como subrayado o tachado, también muestra un ejemplo de como la
fuente podría aparecer, para desplegar la caja de dialogo de fuente se utiliza su método ShowDialog,
la propiedad font mantiene el color seleccionado por el usuario.

Es posible agregar el control FontDialog al formulario aunque este no esté visiblemente contenido en
el formulario pero si visible en la bandeja de componentes o es posible agregar el control FontDialog
a través de código declarando un objeto de este tipo.

Private Sub BtnFont_Click(ByVal sender As [Link], ByVal e As [Link]) _

Handles [Link]
Dim FD As New FontDialog
[Link]()
[Link] = [Link]
End Sub

La caja de FontDialog se muestra asi:

206 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Propiedades

Font - Permite emplear el [Link].

ShowEffects - Si es true, mostrara los efectos del texto.

FixedPitchOnly - Si es true. limita los tipo de letra a utilizar.

ShowColor - Si es true, mostrara un comboBox con los colores.

ShowDialog - Muestra la caja de dailog.

GRAFICOS EN VISUAL STUDIO 2010

TRABAJANDO CON GRAFICAS EN .NET.
La Clase Graphics
Usted puede utilizar el .NET Framework para realzar el interfaz creando Graficos, las líneas, círculos, y
otro forma. Con apenas un par de líneas del código, usted puede exhibir estos gráficos en la forma de
Windows Forms.

El .NET Framework incluye el namespace de [Link] para permitirle crear gráficos o modificar
imágenes existentes. Con el namespace de [Link], usted puede hacer el siguiente:
• Agregar círculos, las líneas, y otras formas a la interfaz dinámicamente..
• Corrige y vuelva a clasificar según el tamaño los cuadros.
• Cambie los cocientes de la compresión de los cuadros ahorrados al disco.
• Agregue las insignias o el texto del copyright de los cuadros.

Lista de las mas Importantes Clases del [Link]

Clase Descripcion
Bitmap Encapsula una BITMAP de GDI+, que consiste en los datos del pixel para una
imagen de los gráficos y sus cualidades. Un objeto a memoria de imagen es un
objeto usado para trabajar con las imágenes definidas por datos del pixel. Ésta es
la clase que usted utilizará cuando usted necesita cargar o ahorrar imágenes.
Font Define un formato particular para el texto, incluyendo cara de la fuente, tamaño,
y cualidades del estilo. Esta clase no puede ser heredada.
FontFamily Define un grupo de tipografías que tienen un diseño básico similar y ciertas
variaciones en estilos. Esta clase no puede ser heredada..
Graphics Encapsula una superficie de dibujo de GDI+. Esta clase no puede ser heredada.
Usted utilizará esta clase cualquier momento usted necesita dibujar líneas, dibuja
formas, o agrega el texto gráfico a un control o a una imagen.
Image Una clase baja abstracta que proporciona la funcionalidad para la BITMAP y el
Metafile descendió clases.
Pen Define un objeto usado para dibujar líneas, curvas, y flechas. Esta clase no puede
ser heredada.
Pens Plumas para todos los colores estándares. Esta clase no puede ser heredada.
Utilice esta clase para evitar de crear un caso de una clase de la pen.
 Capítulo 6: Trabajando con Archivos y Gráficos en Visual Studio 2010 207

Clase Descripcion
SolidBrush Define un cepillo(brush) de un solo color. Los cepillos se utilizan para llenar
formas de los gráficos, tales como rectángulos, elipses, las empanadas, los
polígonos, y las trayectorias. Esta clase no puede ser heredada.
StringFormat Encapsula la información de la disposición del texto (tal como alineación y
línea espaciamiento), manipulaciones de la exhibición (tales como inserción
de los puntos de suspensión y substitución nacional del dígito), y las
características de OpenType. Esta clase no puede ser heredada.
SystemColors Cada característica de la clase de SystemColors es una estructura del color
que es el color de un elemento gráfico de Windows.
SystemFonts Especifica las fuentes usadas para exhibir el texto en elementos gráficos de
Windows.
SystemPens Cada característica de la clase de SystemPens es un objeto de la pluma que
es el color de un elemento gráfico de Windows y que es una anchura de 1.
TextureBrush Cada característica de la clase de TextureBrush es un objeto del cepillo que
utiliza una imagen para llenar el interior de una forma. Esta clase no puede
ser heredada.

De estas clases, usted utilizará los gráficos lo más a menudo posible porque proporciona los métodos
para dibujar al dispositivo de exhibición. La clase Pen se utiliza para dibujar líneas y las curvas, mientras
que las clases derivaron del Brush abstracto de la clase se utilizan para llenar los interiores de formas.
Además, usted debe estar al corriente de la clase de PictureBox, que usted puede utilizar en usos de
las formas de Windows para exhibir una imagen como parte del interfaz utilizador.

Clase Descripcion
CharacterRange Especifica una gama de las posiciones de carácter dentro de una secuencia.
Color Representa el Color
Point Representa un par pedido del número entero x y de coordenadas de y que
define un punto en un plano de dos dimensiones.
PointF Representa un par pedido de la coma flotante x y de los coordenadas de y
que define un punto en un plano de dos dimensiones.
Rectangle Almacena un sistema de cuatro números enteros que representen la
localización y el tamaño de un rectángulo. Para funciones más avanzadas de
la región, utilice un objeto de la región.
RectangleF Almacena un sistema de cuatro números floating-point que representen la
localización y el tamaño de un rectángulo. Para funciones más avanzadas de
la región, utilice un objeto de la región.
Size Almacena un par pedido de números enteros, típicamente la anchura y la
altura de un rectángulo.
208 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ejemplos Cortos de Graficos

Ejemplo 1 – Trabajando con los controles

Private Sub checkBox1_CheckedChanged(sender As Object, e As EventArgs)

If [Link] = true Then
[Link] = new Point(30,100)
End if
End Sub
Private Sub checkBox2_CheckedChanged(sender As Object, e As EventArgs)
If [Link] = true Then
[Link] = 30
[Link] = 200
End if
End Sub
Private Sub checkBox3_CheckedChanged(sender As Object, e As EventArgs)
If [Link] = true Then
[Link] = new Size(50, 35)
Else
[Link] = new Size(220, 35)
End if
End Sub
Private Sub checkBox4_CheckedChanged(sender As Object, e As EventArgs)
If [Link] = true Then
[Link] = [Link]
[Link] = [Link]
Else
[Link] = [Link]
[Link] = [Link]
End if
End Sub
 Capítulo 6: Trabajando con Archivos y Gráficos en Visual Studio 2010 209

Ejemplo 2 – Creando tipos de Lienas

Private Sub Form3_Paint(sender As Object, e As PaintEventArgs)

Dim g As Graphics = [Link]()
Dim p As New Pen([Link], 7)
[Link] = [Link] : [Link](p, 50, 25, 400, 25)
[Link] = [Link]
[Link](p, 50, 50, 400, 50) : [Link] = [Link]
[Link](p, 50, 75, 400, 75)
[Link] = [Link] : [Link](p, 50, 100, 400, 100)
[Link] = [Link]
[Link](p, 50, 125, 400, 125)
End Sub

Ejemplo # 3 – Ubicarle un fondo Grafico a la Ventana

Private Sub Form5_Paint(sender As Object, e As PaintEventArgs)

Dim bm As New Bitmap(“C:\WINDOWS\Web\Wallpaper\[Link]”)
Dim g As Graphics = [Link]()
[Link](bm, 1, 1, [Link], [Link])
End Sub
210 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Otros Conceptos
La clase Graphics proporciona métodos para dibujar objetos en la interfaz de la pantalla, se puede
obtener la clase Graphics llamando al método [Control].CreateGraphics en un objeto que herede de
[Link], ejemplo:

Esta es la clase que realmente dibuja líneas, curvas, figuras, imágenes y texto, para esto necesita un
lienzo donde poder hacerlo, el cual se crea de la siguiente manera:

Dim g As Graphics = [Link]

Las clases y estructuras mas importantes del namespace [Link], las podemos resumir en:

Propiedades más Importantes:

Bitmap - Encapsula un Bitmap GDI+, usado para trabajar con imágenes.

Dim Bmp as New Bitmap(“c:\Img\[Link]”)

[Link] = Bmp

Font - Define el tipo de letra, Al control asociado.

Dim miFuentes as New Font(“Verdana”,25,[Link])

[Link] = miFuentes

FontFamily - Define una familia de tipos de letra con una similitud básica en el diseño y una cierta
variación en el estilo.

Pen - Para dibujar líneas y curvas figuras etc.

Region - Describe o modifica la estructura interior de una superficie

Transform - Obtiene o establece la transformación universal para este Graphics.

Métodos Públicos más Usados:

DrawLine - Dibuja una línea que conecta los dos puntos especificados por los pares de coordenadas.

‘Creando el color de la linea

Dim Lapiz As New Pen([Link])
‘Estilo Incial y Final de la Linea
[Link] = [Link]
[Link] = [Link]
‘Estilo de la Linea
[Link] = [Link]
‘Anchura de la Linea
[Link] = 12
‘Creamos los puntos o extremos de la recta
Dim puntoInicial As New Point(150, 10)
Dim puntoFinal As New Point(250, 80)
‘Dibujando la Linea
[Link](Lapiz, puntoInicial, puntoFinal)
 Capítulo 6: Trabajando con Archivos y Gráficos en Visual Studio 2010 211

DrawRectangle
Dibuja un rectángulo especificado por un par de coordenadas, un valor de ancho y un valor de alto.

‘Creando un rectangulo : Rectangle(Posx, Posy, Ancho, Altura)

Dim Lapiz as New Pen([Link])
[Link] = 4
Dim Rectan as New Rectangle(250,120,50,100)
[Link](lapis, Rectan)

DrawEllipse
Sobrecargado. Dibuja una elipse definida por un rectángulo delimitador especificado por un par de
coordenadas, un valor de alto y un valor de ancho.

‘Creando un rectangulo : Rectangle(Posx, Posy, Ancho, Altura)

Dim Lapiz as New Pen([Link])
[Link] = 4
Dim Rectan as New Rectangle(250,120,100,100)
‘Creando Un Elipse: Es basado desde un Rectangulo
[Link](Lapiz, Rectan)

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

‘Matrix de Puntos
Dim Puntos(2) as Point
Puntos(0) = new Point(400,300)
Puntos(1) = new Point(500,300)
Puntos(2) = new Point(400,200)
Dim lap as new Pen([Link])
[Link](Lap, Puntos)

DrawCurve
Sobrecargado. Dibuja una curva cardinal a través de una matriz especificada de puntos de la clase
Point.

DrawPath
Dibuja un GraphicsPath.

FillEllipse
Sobrecargado. Rellena el interior de una elipse definida por un rectángulo de delimitación especificado
por un par de coordenadas, un valor de alto y un valor de ancho.

FillRectangle
Sobrecargado. Rellena el interior de un rectángulo especificado por un par de coordenadas, un valor
de ancho y un valor de alto.

FillPolygon
Rellena el interior de un polígono definido por una matriz de puntos, este método requiere indicarle el
color de relleno y el polígono transformado en una matriz de puntos.

[Link]([Link], Puntos)
212 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

TranslateTransform
Cambia el origen del sistema de coordenadas anteponiendo la traslación especificada a la matriz de
transformación de este Graphics.

Dim g As Graphics = CreateGraphics

Dim rect As New Rectangle(220, 80, 80, 150)
Dim pen As New Pen([Link])
[Link](pen, rect)
[Link](10, 10)
[Link](pen, rect)

ScaleTransform
Sobrecargado.

Dim g As Graphics = CreateGraphics

Dim rect As New Rectangle(220, 80, 80, 150)
Dim pen As New Pen([Link])
[Link](pen, rect)
rect = New Rectangle(400, 80, 80, 150)
[Link](1.2F, 1.2F)
[Link](pen, rect)

RotateTransform
Sobrecargado.

Dim g As Graphics = CreateGraphics

Dim rect As New Rectangle(400, 40, 80, 150)
Dim pen As New Pen([Link])
[Link](pen, rect)
[Link](10)
[Link](pen, rect)

Clase GraphicsPath
La clase GraphicsPath, del espacio de nombres [Link].Drawing2D, tiene objetos que
representan figuras (líneas y curvas conectadas). Las aplicaciones usan estas secuencias de datos con
líneas y curvas (path) para dibujar los bordes de las figuras, rellenar el interior de las figuras y crear
zonas de recorte. El motor gráfico mantiene las coordenadas de las figuras geométricas en objetos
path. Los objetos path pueden estar formados a su vez por otras figuras.
 Capítulo 6: Trabajando con Archivos y Gráficos en Visual Studio 2010 213

Las aplicaciones usan trazados para dibujar los contornos de formas, rellenar el interior de formas y
crear áreas de recorte. El motor de gráficos mantiene las coordenadas de las formas geométricas de
un trazado en un espacio de coordenadas universales.

Un trazado puede estar formado por un número indeterminado de figuras (subtrazados). Cada figura
está formada por una secuencia de líneas y curvas conectadas o por una forma geométrica primitiva. El
punto inicial de una figura es el primer punto de la secuencia de líneas y curvas conectadas. El extremo
es el último punto de la secuencia. Los puntos iniciales y finales de una forma geométrica primitiva se
definen mediante la especificación primitiva.

Usando la clase GraphicsPath

Dim Rectan As New Rectangle(0, 0, 200, height)

Dim gPath As New GraphicsPath
[Link](Rectan)
Dim puntos(2) As Point
puntos(0) = New Point(400, 300)
puntos(1) = New Point(500, 300)
puntos(2) = New Point(400, 200)
[Link](puntos)
[Link]([Link], puntos)
Dim Rectan2 As New Rectangle(250, 120, 100, 100)
[Link](Rectan2)

Region = New Region(gPath)

Ejemplo de Generacion de Barras Estadisticas con Gráficos

Empezando a realizar el laboratorio para tratamiento de Gráficos:
Para esto primero crearemos un formulario con el nombre frmEstadisticas, el cual debe tener el
siguiente diseño:

Crear una matriz de ámbito global en el formulario:

Dim Agencias(1, 8) As String

214 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

En el botón agregar, se debe agregar lo siguiente:

Dim sAgencia As String = [Link]

Dim Porc As String = [Link]
Dim I As Integer = [Link]

If I < 9 Then
[Link](sAgencia + “ “ + Porc + “%”)
Agencias(0, I) = sAgencia
Agencias(1, I) = Porc
Else
[Link](“Solo hasta 9 Agencias”, “Ventas”)
End If

Dentro del formulario crear el siguiente método DibujarBarra:

Sub DibujaBarra(ByVal Num As Integer, ByVal Altura As Integer, ByVal Titulo As

String)
Dim g As Graphics = [Link]
Dim NumBarra As Integer = 40 + 65 * Num
Dim H As Integer = Altura
‘Dibujamos la Line base
Dim p1 As New Point(20, 280)
Dim p2 As New Point(NumBarra + 85, 280)
Dim LinX As New Pen([Link])
[Link] = 2

Dim Barra As New Rectangle(NumBarra, 280 - h, 55, h)

[Link] = [Link]
[Link]([Link], Barra)
[Link](LinX, Barra)
‘Dibujando el Titulo
Dim miFuente As New Font(“Verdana”, 7, [Link])
[Link](Titulo, miFuente, [Link],
NumBarra, 290)

[Link] = 4
[Link] = [Link]
[Link](LinX, p1, p2)

End Sub

Por último en el botón graficar colocamos:

Dim i as Integer
For i = 0 to [Link](1)
Dim Porc as Integer = cInt(Agencia(1,i))
Dim Nombre as string = Agencia(0,i)
DibujaBarra(I, Porc, Nombre)
Next
 Capítulo 6: Trabajando con Archivos y Gráficos en Visual Studio 2010 215

Al ejecutar el siguiente ejemplo se debe observar lo siguiente:

Ejemplo de Graficos – Modificando Formas de Letrras

216 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Propiedades de los Controles

Control Propiedades Valor

textbox (name) txtTexto
Text Graficos Letras
Button (name) cmdShadow
Text Texto Sombra
NumericUpDown (name) nuSize
Value 100
NumericUpDown (name) nuShadowDepth
Value 20

Ahora codificamos, el script del botón de sombra

Private Sub Sobreado(ByVal sender As [Link], _

ByVal e As [Link]) Handles [Link]
‘Texto artístico con Sombra
‘Definicón del objeto grafico, pincel
Dim grafico As Graphics
‘Para Shadow se definen los colores de fuente y de la sombra
Dim pincelSombra As Brush = [Link]
Dim pincelFuente As Brush = [Link]
‘Creamos la fuente
Dim miLetra As New Font(“Times New Roman”, [Link], _
[Link], [Link])
‘CREACION DEL GRAFICO
grafico = [Link]
[Link]([Link])
‘Calcular el tamaño del texto
Dim TextoSize As SizeF
TextoSize = [Link]([Link], miLetra)
‘Los valores para la ubicación
Dim xPos, yPos As Single
xPos = ([Link] - [Link]) / 2
yPos = ([Link] - [Link]) / 2
‘Ya están definidos los elementos: ‘Grafico, Pinceles, Fuente, Tamaño y posición
‘Dibujar el texto ahora...usar el método DrawString
‘Primero la sombre y luego el frente.
[Link]([Link], miLetra, pincelSombra, _
xPos + [Link], yPos + [Link])
[Link]([Link], miLetra, pincelFuente, _
xPos, yPos)
End Sub
 CAPÍTULO

7
Collection and Generics
NameSpaces y Bibliotecas de Clases
 CAPÍTULO
Collection and Generics
7 NameSpaces y Bibliotecas
de Clases
MENSAJES Y CREACIÓN DE MATRICES
Una matriz es una secuencia de elementos de datos del mismo tipo. Podemos acceder a elementos
individuales de una matriz utilizando el nombre de la matriz y un índice o índices (empezando por 0)
para especificar la posición del elemento en la matriz. Una matriz tiene una o más dimensiones con
uno o más elementos en cada dimensión.

Para acceder a los elementos individuales utilizando índices enteros:

Ejemplo de Definición de Matriz en Forma Explicita.

Ejemplo de Definición de Matriz en Forma Implícita.

Ejemplo de Definición de Matriz en Forma Dinámica.

220 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

El problema de ReDim es que redimensiona a la matriz blanqueando la matriz, para evitar esto,
podemos agregar la palabra clave Preserve, después de las líneas anteriores colocar lo siguiente:

Limites de una Matriz

COLECCIONES EN .NET FRAMEWORK

.NET Framework ofrece clases especializadas para almacenamiento y recuperación de datos. Estas
clases proporcionan compatibilidad con pilas, colas, listas y tablas hash. La mayoría de las clases
de colección implementan las mismas interfaces. Si es necesario, puede crear sus propias clases de
colección implementando estas interfaces.

Colecciones
ArrayLIst
Queue
Stack
Hashtable
SortedLIst
listDiccionary
HybridDiccionary
OrderedDiccionary
StringCollection
StringDiccionary

Los siguientes tipos genéricos corresponden a los tipos de colección existentes

 Capítulo 7: Collection and Generics - NameSpaces y Bibliotecas de Clases 221

Clase ArrayLIst
La clase ArrayList es una simple contenedoras para objetos de cualquier tipo. La adición y eliminación
de elementos y artículos de la clase es muy sencillo.

Dim coll As New ArrayList()

‘Adicionar Individualmente a la coleccion
Dim s As String = “Hello”
[Link](s)
[Link](“hi”)
[Link](50)
[Link](New Object())

Además de apoyar el método Add, el ArrayList apoya el método AddRange para añadir una serie de
temas, por lo general de una serie u otra colección. El siguiente código proporciona un ejemplo:

‘Utilizando en Metodo ADDRange

Dim anArray() As String = {“more”, “or”, “less”}
[Link](anArray)

El método AddRange apoya la adición de una serie de temas de cualquier objeto que soporta la interfaz
ICollection (que incluye todos los arreglos, ArrayList objetos, colecciones y más discutidos en este capítulo).
La colección ArrayLists también apoyo la inserción de objetos en posiciones específicas. Para lograr
esta tarea, un ArrayList también apoya el Método InsertRange.

También se pude insertar en una ubicación específica un rango de valores.

El siguiente código proporciona un ejemplo:

‘Insertar en Forma Directa

[Link](3, “Hola Q Tal”)
‘Insertar en Forma Directa un AddRange
Dim moreString() As String = {“Buenas Noches”, “Nos Vemos”}
[Link](3, moreString)

Además del Método Insert y Add , también puede utilizar el indice para establecer un una ubicación
exacta, tal y como se muestra en el siguiente código:

coll(3) = “Hey All”

Por último, el ArrayList apoya la eliminación de los artículos de la colección. Tres métodos de apoyo a
la eliminación de temas: Remove, RemoveAt, y RemoveRange.

Eliminar el método se demuestra en el siguiente ejemplo:

‘Eliminar Datos de la Coleccion

[Link](“Nos Vemos”)
[Link](“Nos Vemos”)
‘Eliminacion por Valor del Indice El 1er elemento de la Arrays
[Link](0)
‘Elimnar los 4 primeros Items
[Link](0, 4)
222 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

La clase ArrayList apoya también algunos otros métodos que son útiles para añadir y eliminar objetos
de la colección:
El método Clear se utiliza para vaciar una coleccion con todos sus elementos.
El método Index se utiliza para determinar el índice de un determinado items de la colección.
El método Contains se utiliza para probar si un objeto existe en la colección.

Mediante la utilización de estos métodos, ud. puede realizar en forma mas compleja el proceso de
agregar y quitar artículos dentro de la colección, tal como se muestra en este ejemplo:

Dim myString As String = “Mi Cadena”

If [Link](myString) Then
Dim index As Integer = [Link](myString)
[Link](index)
Else
[Link]()
End If

El ArrayList apoya un método para ordenar una colección de artículos. Para ordenar los elementos
dentro de un ArrayList, basta con llamar al método Sort de la ArrayList de este modo:

[Link]()

Ahora veamos el ejercicio completo

Module Module6
Sub main()
‘Colections - Array List
‘Utilizando el Metodo ADD
Dim Coll As New ArrayList()
‘Adicionar Individualmente a la coleccion
Dim s As String = “Hola”
[Link](s) : [Link](“hi”) : [Link](50)
[Link](New Object())
‘Utilizando en Metodo ADDRange
Dim anArray() As String = {“Fatima”, “Lili”, “Luis”}
[Link](anArray)
[Link](3, “Hola Q Tal”) ‘Insertar en Forma Directa
‘Insertar en Forma Directa un AddRange
Dim moreString() As String = {“Buenas Noches”, “Nos Vemos”}
[Link](3, moreString)
Coll(3) = “Buenas Dias” ‘Sobreescribir Forma Directa
[Link](“Nos Vemos”)
[Link](“Nos Vemos”)’Eliminar Datos de la Coleccion
[Link](0) ‘Eliminacion por Valor del Indice El 1er elemento de la
Arrays
‘Elimnar los 4 primeros Items
[Link](0, 4)
Dim enumerator As IEnumerator = [Link]()
While [Link]()
[Link]([Link])
End While
Dim x As Integer
For x = 0 To [Link] - 1 Step +1
[Link](Coll(x))
Next
[Link]()
End Sub
End Module
 Capítulo 7: Collection and Generics - NameSpaces y Bibliotecas de Clases 223

Ejemplo: Manejo de Colecciones

Almacena Datos de las Variables lo cual lo convierte en una colección de datos que lo agrega al
datagridview por filas.

Ahora vamos a empezar a codificar lo siguiente en los eventos de la ventana

Public Class FrmArrays

Private Sub btnLimpiar_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Dim contador As Integer
For contador = 0 To [Link] - 1
If TypeOf ([Link](contador)) Is TextBox Or TypeOf (GroupBox1.
Controls(contador)) Is MaskedTextBox Then
[Link](contador).Text = “”
End If
Next
End Sub

Private Sub btnAgregar_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Dim arreglo As String() = {[Link], [Link], [Link], MskTel.
Text}
[Link](arreglo)
[Link]([Link])

End Sub
End Class
224 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

El formulario nos mostrara como resultado lo siguiente

CLASES [Link]
Las clases del espacio de nombres [Link] no almacenan los elementos como objetos de
un tipo específico, sino como objetos de tipo Object.

En la tabla siguiente se muestran algunas de las clases que se utilizan comúnmente:

Clase Descripcion
ArrayList Implementa la interfaz IList utilizando una matriz cuyo tamaño aumenta
dinámicamente cuando es necesario.
BitArray Administra una matriz compacta de valores de bit, que se representan como
valores Boolean, donde True indica que el bit está activado (1) y False indica que
el bit está desactivado (0).
Hashtable Representa una colección de pares de clave y valor que se organizan por código
hash de la clave.
Queue Representa una colección de objetos primero en entrar, primero en salir (FIFO).
Stack Representa una colección simple no genérica de objetos último en entrar, primero
en salir (LIFO).

Clases [Link] y [Link]

Proporciona tipos genéricos que permiten crear colecciones con establecimiento inflexible de tipos y
especificar el tipo de datos de los elementos cuando se crean.

Colecciones Genéricas
Es recomendable utilizar colecciones genéricas porque se obtiene la ventaja inmediata de la seguridad
de tipos sin necesidad de derivar de un tipo de colección base e implementar miembros específicos
de los tipos. Además, por lo general los tipos de colección genéricos tienen un mejor rendimiento que
los tipos de colección no genéricos correspondientes (y mejor que el de los tipos derivados de tipos de
colección base no genéricos) cuando los elementos de la colección son tipos de valor, porque con los
genéricos no hay necesidad de realizar conversiones boxing de los elementos.
 Capítulo 7: Collection and Generics - NameSpaces y Bibliotecas de Clases 225

Clase Descripcin
Collection Proporciona la clase base para una colección genérica.
Dictionary Representa una colección de pares de clave y valor que se organizan por
claves.
KeyedCollection Proporciona la clase base abstracta para una colección cuyas claves están
incrustadas dentro de los valores.
LinkedList Representa una lista doblemente vinculada.
LinkedListNode Representa un nodo en una clase LinkedList. Esta clase no puede heredarse.
List Implementa la interfaz IList utilizando una matriz cuyo tamaño aumenta
dinámicamente cuando es necesario.
Queue Representa una colección de objetos primero en entrar, primero en salir
(FIFO).
SortedDictionary Representa una colección de pares de clave y valor que se ordenan por claves.
SortedList Representa una colección de pares de clave y valor que se ordenan por
claves según la implementación de la interfaz IComparer asociada.
Stack Representa una colección último en entrar, primero en salir (LIFO) de
tamaño variable con instancias del mismo tipo arbitrario.
ReadOnlyCollection Proporciona la clase base para una colección genérica de sólo lectura.

Clases [Link]
Proporciona clases de colección especializadas y con establecimiento inflexible de tipos, como
colecciones de sólo cadena y diccionarios híbridos y de lista vinculada.

En la tabla siguiente se muestran algunas de las clases que se utilizan comúnmente:

Clase Descripción
CollectionsUtil Crea colecciones que omiten el uso de mayúsculas y minúsculas en
cadenas.
HybridDictionary Implementa la interfaz IDictionary utilizando ListDictionary mientras
la colección es pequeña; a continuación, cambia a Hashtable cuando
la colección aumenta.
ListDictionary Implementa la interfaz IDictionary utilizando una lista vinculada
única. Se recomienda para las colecciones que normalmente
contienen 10 elementos o menos.
NameObjectCollectionBase Proporciona la clase base abstracta para una colección de claves
de cadena y valores de objeto asociados a los que se puede tener
acceso con la clave o con el índice.
NameValueCollection Representa una colección de claves de cadena y valores de cadena
asociados a los que se puede tener acceso con la clave o con el índice.
OrderedDictionary Representa una colección de pares de clave y valor que se ordenan
por claves o por índices.
StringCollection Representa una colección de cadenas.
StringDictionary Implementa una tabla hash con la clave y el valor con establecimiento
inflexible de tipos de forma que sean cadenas en lugar de objetos.
226 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Clases [Link]
El espacio de nombres [Link] proporciona clases de colección especializadas
y con establecimiento inflexible de tipos, como colecciones de sólo cadena y diccionarios híbridos y de
lista vinculada.

Mostremos un ejemplo de cómo podemos crear una colección sencilla

Dim Facultades as New Collection

Los 2 metodos clasicos para agregar y eliminar elementos de una colección son Add y Remove

Module Colecciones
Sub main()
Dim Facultades as New Collection
Dim Facultad as string
[Link](“Ciencias Fisicas y Matematicas”,”FACFyM”)
[Link](“Ingenieria Mecanica y Electrica”,”FIXE”)
[Link](“Educación y Ciencias Sociales”,”FACHSE”)
[Link](“Ingenieria Quimica”,”FIQIA”)
‘Eliminamos indicando el Indice
[Link](3)
‘Eliminamos Indicando Clave(key)
[Link](“FACFyX”)
For Each Facultad in Facultades
[Link](Facultad)
Next
[Link]()
End Module

Mostremos otra forma de poder realizarlo

Module Colecciones
Sub main()
Dim Facultades as New Collection
Dim Facultad as string
[Link](“Ciencias Fisicas y Matematicas”,”FACFyM”)
[Link](“Ingenieria Mecanica y Electrica”,”FIXE”)
‘Insercion de Nuevo Elemento una Posición Anterior a FiXE
[Link](“Educación y Ciencias Sociales”,”FACHSE”,”FIXE”)
‘Insercion de nuevo elemento una posición después de FACFyM
[Link](“Ingenieria Quimica”,”FIQIA”, , 1)
For Each Facultad in Facultades
[Link](Facultad)
Next
[Link](“Total de Facultades {0}”,[Link])
[Link]()
End Module
 Capítulo 7: Collection and Generics - NameSpaces y Bibliotecas de Clases 227

Cuándo utilizar colecciones genéricas

Es recomendable utilizar colecciones genéricas porque se obtiene la ventaja inmediata de la seguridad
de tipos sin necesidad de derivar de un tipo de colección base e implementar miembros específicos
de los tipos.

Las clases y los métodos genéricos combinan reusabilidad, seguridad de tipos y eficacia de una
manera que sus homólogos no genéricos no pueden. Los tipos genéricos se utilizan comúnmente
con las colecciones y los métodos que funcionan en ellas. La versión 2.0 de la biblioteca de clases
de .NET Framework proporciona un nuevo espacio de nombres, [Link], que
contiene varias clases nuevas de colección basadas en tipos genéricos. Se recomienda que todas las
aplicaciones cuyo destino es la versión 2.0 utilicen las nuevas clases de colección genéricas en lugar de
sus homólogas no genéricas anteriores como ArrayList.

Además, por lo general los tipos de colección genéricos tienen un mejor rendimiento que los tipos de
colección no genéricos correspondientes (y mejor que el de los tipos derivados de tipos de colección
base no genéricos) cuando los elementos de la colección son tipos de valor, porque con los genéricos
no hay necesidad de realizar conversiones boxing de los elementos.

Los siguientes tipos genéricos corresponden a los tipos de colección existentes:

• List es la clase genérica que corresponde a ArrayList.
• Dictionary es la clase genérica que corresponde a Hashtable.
• Collection es la clase genérica correspondiente a CollectionBase. Collection se puede usar como
una clase base pero, a diferencia de CollectionBase, no es abstracta, lo que hace que sea mucho
más fácil de utilizar.
• ReadOnlyCollection es la clase genérica que corresponde a ReadOnlyCollectionBase.
ReadOnlyCollection no es abstracta y tiene un constructor que hace que sea fácil exponer una List
como una colección de sólo lectura.
• Las clases genéricas Queue, Stack y SortedList corresponden a las respectivas clases no genéricas
que tienen los mismos nombres.

Tipos adicionales
Hay varios tipos de colección genéricos que no tienen homólogos no genéricos:
• LinkedList es una lista vinculada de uso general que proporciona operaciones de inserción y
eliminación O(1).
• SortedDictionary es un diccionario ordenado con operaciones de inserción y eliminación O (logn),
lo que hace de él una alternativa útil a SortedList.
• KeyedCollection es un híbrido entre una lista y un diccionario, lo que proporciona una manera de
almacenar objetos que contienen sus propias claves.

Funcionalidad adicional
Algunos de los tipos genéricos tienen funcionalidades que no se encuentran en los tipos de colección
no genéricos. Por ejemplo, la clase List, que corresponde a la clase ArrayList no genérica, tiene una
serie de métodos que aceptan delegados genéricos, como el delegado Predicate que le permite
especificar métodos para buscar en la lista, el delegado Action que representa métodos que actúan
en cada uno de los elementos de la lista, y el delegado Converter que le permite definir conversiones
entre tipos.
228 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

La clase List le permite especificar sus propias implementaciones de interfaces genéricas de IComparer
para ordenar la lista y buscar en ella. Las clases SortedDictionary y SortedList también tienen esta
capacidad y, además, permite especificar los comparadores cuando se crea la colección. De forma
parecida, las clases Dictionary y KeyedCollection le permiten especificar sus propios comparadores
de igualdad.

Ejemplo: Trabajando con el SortedList

El SortedList Representa una colección de pares de clave y valor ordenados por claves a los que se puede
tener acceso por clave y por índice. En el ejemplo lo utilizamos como columna para el datagridview y
así poder almacenar los datos por filas.

Ahora empezamos a realizar la codificación

Imports [Link]
Public Class FrmSortedList
Dim articulos As String() = {“Seleccione”, “Televisor”, “Computadora”,
“MiniComponentes”, “Lavadora”}
Dim precio As Double() = {0.0, 1300.0, 2800.0, 1800.0, 1000.0}
Private Sub btnSalir_Click(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
Close()
End Sub

Private Sub btnLimpiar_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
[Link] = 0
[Link] = “0.00”
[Link] = 1
[Link] = True
[Link]()
End Sub
 Capítulo 7: Collection and Generics - NameSpaces y Bibliotecas de Clases 229

Seguiremos codificando los siguientes eventos del formulario

Private Sub btnIngresar_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
If [Link] = 0 Then
MsgBox(“Seleccione Articulo”)
Return
End If
Dim subtotal, total, igv, precio
subtotal = 0.0 : total = 0.0 : igv = 0.0 : precio = 0.0
If [Link] = True Then
precio = CDbl([Link]) * CInt([Link])
igv = precio * 0.19
subtotal = precio - igv
total = precio + igv
ElseIf [Link] = True Then
precio = CDbl([Link]) * CInt([Link])
subtotal = precio
total = precio
End If
Dim TemArray As String() = {[Link], [Link], NumericUpDown1.
[Link], [Link], [Link], _
[Link]}
Dim i As Integer = 0
Dim MyTargetArray As DictionaryEntry()
For Each S In TemArray
MyTargetArray(i).Key = i
MyTargetArray(i).Value = S
Next
Dim llenar As String = “”
Dim a As Integer
For a = 0 To [Link]
llenar = llenar + MyTargetArray(a).Value + “ -”
Next
[Link](llenar)
[Link]([Link])
End Sub

Private Sub FrmSortedList_Load(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
[Link] = articulos
Dim MYSourceLIst As new SortedList
[Link](0, “Detalle Cant Prec SubT Igv
Total”)
Dim obj As New DataGridViewTextBoxColumn()
[Link] = MYSourceLIst(0).ToString
[Link] = MYSourceLIst(0).ToString
[Link](obj)
[Link](0).Width = 500
End Sub

Ahora seleccionamos el combobox para empezar a codificarlo en el evento para seleccionar

Private Sub cmbArticulos_SelectedIndexChanged(ByVal sender As [Link],

ByVal e As [Link]) Handles [Link]
[Link] = precio([Link]).ToString
End Sub
End Class
230 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Como resultado nos mostraría lo siguiente:

QUE SON GENERICOS

Genéricos forman parte del tipo de sistema .NET Framework que le permite definir un tipo dejando
algunos detalles sin especificar. En lugar de especificar los parámetros de tipos o miembros clases ,
puede permitir que el código se de al momento de especificar. Esto permite que el programador pueda
adaptar su tipo a sus necesidades específicas.

El. NET Framework versión 2,0 hacia adelante incluye varias clases genéricas en el namespace System.
[Link], incluido Dictionary, Queue, SortedDictionary, y SortedList. Estas clases de trabajo
es igual que sus homólogos no generic en [Link], pero que ofrecen un mejor rendimiento
y el tipo de seguridad.

¿Por qué el uso de genéricos?

Las versiones 1,0 y el 1,1 de la. NET Framework no apoya los genéricos. En lugar de ello, los
desarrolladores utilizan la clase de objetos para los parámetros y los miembros y arrojara a otras clases
y objetos de la clase. Generics ofrecen dos ventajas significativas sobre el uso de la clase de objetos:

La reducción de tiempo de ejecución errores El compilador no puede detectar el tipo de errores cuando
se emitieron desde y hacia la clase de objetos. Por ejemplo, si emite una cadena a un objeto de clase
y luego tratar de emitir ese objeto a un entero, el compilador no captura el error. En lugar de ello, el
tiempo de ejecución va a lanzar una excepción. El uso de genéricos permite que el compilador capture
este tipo de error antes de que su programa se ejecuta. Además, puede especificar las restricciones
para limitar las clases utilizadas en un nombre genérico, lo que permite al compilador detectar un tipo
incompatible.

Mejora del rendimiento requiere Casting boxing y unboxing que roba tiempo de procesador y retarda
el rendimiento. El uso de genéricos no requiere de fundición o de boxeo, lo que mejora en tiempo de
ejecución.
 Capítulo 7: Collection and Generics - NameSpaces y Bibliotecas de Clases 231

En primer lugar, examinar las siguientes clases. Clases Obj y Gen tienen exactamente las mismas
tareas, pero Obj utiliza la clase de objetos para permitir cualquier tipo que se aprobó, mientras Gen
usos genéricos:

Class Obj
Public V1 As Object
Public V2 As Object
Public Sub New(ByVal _V1 As Object, ByVal _V2 As Object)
V1 = _V1
V2 = _V2
End Sub
End Class

Class Gen(Of T, U)
Public V1 As T
Public V2 As U
Public Sub New(ByVal _V1 As T, ByVal _V2 As U)
V1 = _V1
V2 = _V2
End Sub
End Class

Como puede ver, la clase Obj cuenta con dos miembros del tipo de objeto. La clase Gen tiene dos
miembros de tipo T y U. El consumo de código determinará los tipos de T y U. Dependiendo de la
forma en que el consumo de código utiliza la clase Gen, T y U podría ser un string, un int, una clase
customizada, o cualquier combinación de éstos.

Sub main()
‘Adicionar 2 cadenas usando el objeto CLASS
Dim oa As Obj = New Obj(“Hola, “, “Como Estas!”)
[Link](CType(oa.V1, String) + CType(oa.V2, String))
‘ Adicionar 2 cadenas usando el objet GEN
Dim ga As New Gen(Of String, String)(“Hola, “, “Como Estas!”)
[Link](ga.V1 + ga.V2)

‘Adicionar un Double y un Integer usandi las clase OBJ

Dim ob As Obj = New Obj(10.125, 2005)
[Link](CType(ob.V1, Double) + CType(ob.V2, Integer))
‘Adicionar un Double y un Integer usando las clase GEN
Dim gb As New Gen(Of Double, Integer)(10.125, 2005)
[Link](gb.V1 + gb.V2)
End Sub

¿Cómo usar Contraints?

Los Generics sería muy limitado si sólo puede escribir código que compilar de cualquier clase, ya que
se limitaría a las capacidades de la base de la clase de objetos. Para superar esta limitación, los tipos
que consumen código puede ser sustituido por su carácter genérico.

Generics apoyar cuatro tipos de limitaciones:

• Permitir sólo la interfaz que la aplicación de tipos específicos de interfaces para su uso genérico.
• Base Permitir sólo la clase que coincidan con los tipos o heredan de una clase base a su uso genérico.
• Constructor tipos Exigir que su uso genérico para poner en marcha un parameterless constructor.
• O el valor de referencia tipo tipos Exigir que su uso genérico para ser una referencia o tipo de valor.
232 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Por ejemplo, la siguiente clase genérica puede ser utilizada sólo por los tipos que apliquen la interfaz
IComparable:

Class CompGen(Of T As IComparable)

Public t1 As T
Public t2 As T

Public Sub New(ByVal _t1 As T, ByVal _t2 As T)

t1 = _t1
t2 = _t2
End Sub

Public Function Max() As T

If [Link](t1) < 0 Then
Return t1
Else
Return t2
End If
End Function
End Class

Ejemplo: Trabajando con el StringCollection

El stringCollection Representa una colección de cadenas. La clase StringCollection acepta referencia
de objeto null (Nothing en Visual Basic) como valor válido y admite elementos duplicados.

Las comparaciones de cadenas distinguen entre mayúsculas y minúsculas. En el ejemplo lo cual

utilizamos para enlazar los datos mediante el rango que le damos desde el arreglo para su comparación
y así poder agregarle los datos al datagridview

Ahora empezaremos a codificar los eventos del formulario:

En primer lugar definimos las clases a utilizar

Imports [Link]
Imports [Link]
 Capítulo 7: Collection and Generics - NameSpaces y Bibliotecas de Clases 233

Ahora codificamos los eventos:

Public Class FrmStringCollection

Private Sub FrmStringCollection_Load(ByVal sender As [Link], ByVal e As
[Link]) Handles [Link]
[Link] = Now
End Sub

Private Sub btnSalir_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Close()
End Sub

Ahora trabajaremos con el evento limpiar y el evento valida

Private Sub btnLimpiar_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Dim contador As Integer
For contador = 0 To [Link] - 1
If TypeOf ([Link](contador)) Is TextBox Then
[Link](contador).Text = “”
End If
Next
End Sub
Private Function valida() As Boolean
Dim enc As Boolean = False
If ([Link] = “” Or [Link] = “” Or [Link] = “” Or [Link]
= “”) Then
MsgBox(“No debe dejar campos vacios”)
Return enc = True
End If
Return enc
End Function

Ahora adicionamos el script para el evento Agregar, que es el proceso que carga

Private Sub btnAgregar_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
If valida() = True Then
Return
End If
Dim prom As Integer
Dim n1, n2, n3 As Double
n1 = CDbl([Link])
n2 = CDbl([Link])
n3 = CDbl([Link])
prom = CInt((n1 + n2 + n3) / 3)
Dim mycol As New StringCollection()
Dim MyArray As String() = {[Link], [Link], [Link], txtN3.
Text, [Link]}
[Link](MyArray)
If ([Link] = [Link]) Then
[Link](MyArray)
[Link]([Link])
End If
End Sub
End Class
234 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ejemplo: Trabajando con el Queue

El Queue, nos devolverá un array con cada una de las funciones que están encoladas en ese momento.
Es una colección de datos lo cual a ello le pasamos todos los datos que tiene el arreglo para que ambos
tenga la longitud correspondiente para poder compararlos y poder agregarlos al datagridview.

Ahora codificamos los eventos:

Dim arreglo As String() = {“::Seleccione”, “Lima”, “Huancayo”, “Huaraz”, “ica”,

“Piura”}
Private Sub btnSalir_Click(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
Close()
End Sub

Private Sub btnLimpiar_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Dim contador As Integer
For contador = 0 To [Link] - 1
If TypeOf ([Link](contador)) Is TextBox Then
[Link](contador).Text = “”
End If
Next
[Link] = 0
End Sub
 Capítulo 7: Collection and Generics - NameSpaces y Bibliotecas de Clases 235

Ahora desarrollemos los siguientes eventos:

Private Sub FrmQueque_Load(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
[Link] = arreglo
End Sub

Private Sub txtPrecio_KeyPress(ByVal sender As Object, ByVal e As [Link].

[Link]) Handles [Link]
If [Link] = “” Then
Return
End If
Dim precio As Double = CDbl([Link])
If (precio > 0 And precio <= 10) Then
[Link] = “10.00”
ElseIf (precio > 10 And precio <= 20) Then
[Link] = “25.00”
ElseIf (precio > 20 And precio <= 30) Then
[Link] = “35.00”
ElseIf (precio > 30) Then
[Link] = “50.00”
End If
End Sub
Private Function valida() As Boolean
Dim val As Boolean = False
If ([Link] = “” Or [Link] = “” Or [Link] = “” Or txtRemi.
Text = “”) Then
MsgBox(“No deje los campos vacios”)
Return val = True
End If
Return val
End Function

Private Sub btnAgregar_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Dim I As Integer = 0
If valida() = True Then
Return
End If
Dim arreglo As String() = {[Link], [Link], [Link],
[Link], [Link]}
Dim myQ As New Queue()
For I = 0 To [Link] - 1
[Link](arreglo(I).ToString)
Next
If ([Link] = [Link]) Then
[Link](arreglo)
[Link]([Link])
End If
End Sub
236 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

BIBLIOTECAS DE CLASES DE FUNCIONES EN VISUAL BASIC .NET

La clase Math
Permite utilizar funciones matemáticas muy útiles, a continuación veremos un cuadro extraído de la
ayuda y seguidamente ejemplos de su aplicación:

Campos públicos

E Representa la base logarítmica natural, especificada por la constante, e.

PI Representa la relación entre la longitud de la circunferencia de un círculo y su diámetro,
especificada por la constante π.

Métodos públicos

Abs Sobrecargado. Devuelve el valor absoluto de un número especificado.

Acos Devuelve el ángulo cuyo coseno es el número especificado.
Asin Devuelve el ángulo cuyo seno es el número especificado.
Atan Devuelve el ángulo cuya tangente corresponde al número especificado.
Atan2 Devuelve el ángulo cuya tangente es el cociente de dos números especificados.
BigMul Calcula el producto completo de dos números de 32 bits.
Ceiling Devuelve el número entero más pequeño mayor o igual que el número
especificado.
Cos Devuelve el coseno del ángulo especificado.
Cosh Devuelve el coseno hiperbólico del ángulo especificado.
DivRem Sobrecargado. Devuelve el cociente de dos números y pasa también como
parámetro de salida el resto de la división.
Exp Devuelve e elevado a la potencia especificada.
Floor Devuelve el número entero más grande menor o igual que el número especificado.
IEEERemainder Devuelve el resto de la división de dos números especificados.
Log Sobrecargado. Devuelve el logaritmo de un número especificado.
Log10 Devuelve el logaritmo en base 10 de un número especificado.
Max Sobrecargado. Devuelve el mayor de dos números especificados.
Min Sobrecargado. Devuelve el menor de dos números.
Pow Devuelve un número especificado elevado a la potencia especificada.
Round Sobrecargado. Devuelve el número más próximo al valor especificado.
Sign Sobrecargado. Devuelve un valor que indica el signo de un número.
Sin Devuelve el seno del ángulo especificado.
Sinh Devuelve el seno hiperbólico del ángulo especificado.
Sqrt Devuelve la raíz cuadrada de un número especificado.
Tan Devuelve la tangente del ángulo especificado.
Tanh Devuelve la tangente hiperbólica del ángulo especificado.
 Capítulo 7: Collection and Generics - NameSpaces y Bibliotecas de Clases 237

La clase Array
Permite crear, manipular, buscar y ordenar arreglos, por lo tanto, sirve como clase base para todos los
arreglos de Common Language Runtime. A continuación veremos un cuadro extraído de la ayuda y
seguidamente ejemplos de su aplicación:

Propiedades públicas

IsFixedSize Obtiene un valor que indica si Array tiene un tamaño fijo.

IsReadOnly Obtiene un valor que indica si Array es de sólo lectura.
IsSynchronized Obtiene un valor que indica si el acceso a Array está sincronizado (seguro
para la ejecución de subprocesos).
Length Obtiene un entero de 32 bits que representa el número total de elementos
de todas las dimensiones de Array.
LongLength Obtiene un entero de 64 bits que representa el número total de elementos
de todas las dimensiones de Array.
Rank Obtiene el rango (número de dimensiones) de Array.
SyncRoot Obtiene un objeto que se puede utilizar para sincronizar el acceso a Array.

Métodos públicos

BinarySearch Sobrecargado. Busca un valor en una matriz Array unidimensional y

ordenada utilizando un algoritmo de búsqueda binario.
Clear Establece un intervalo de elementos de Array en cero, false o una
referencia nula (Nothing en Visual Basic), en función del tipo de elemento.
Clone Crea una copia superficial de Array.
Copy Sobrecargado. Copia una sección de una matriz Array en otra matriz Array
y realiza la conversión de tipos y la conversión boxing de tipos necesarias.
CopyTo Sobrecargado. Copia todos los elementos del objeto Array unidimensional
actual en el objeto Array unidimensional especificado.
CreateInstance Sobrecargado. Inicializa una nueva instancia de la clase Array.
Equals (se hereda de Sobrecargado. Determina si dos instancias de Object son iguales.
Object)
GetEnumerator Devuelve IEnumerator correspondiente a Array.
GetHashCode (se Sirve como función hash para un tipo concreto, apropiado para su
hereda de Object) utilización en algoritmos de hash y estructuras de datos como las tablas
hash.
GetLength Obtiene un entero de 32 bits que representa el número de elementos de
la dimensión especificada de Array.
GetLongLength Obtiene un entero de 64 bits que representa el número de elementos de
la dimensión especificada de Array.
GetLowerBound Obtiene el límite inferior de la dimensión especificada de Array.
GetType Obtiene el objeto Type de la instancia actual.
GetUpperBound Obtiene el límite superior de la dimensión especificada de Array.
238 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

GetValue Sobrecargado. Obtiene el valor del elemento especificado de la matriz

Array actual. Los índices se especifican en forma de una matriz de enteros
de 32 bits.
IndexOf Sobrecargado. Devuelve el índice de la primera aparición de un valor en
una matriz Array unidimensional o en una parte de la matriz Array.
Initialize Inicializa todos los elementos de la matriz Array de tipo de valor llamando
al constructor predeterminado del tipo de valor.
LastIndexOf Sobrecargado. Devuelve el índice de la última aparición de un valor en
una matriz Array unidimensional o en una parte de la matriz Array.
Reverse Sobrecargado. Invierte el orden de los elementos de una matriz Array
unidimensional o de una parte de Array.
SetValue Sobrecargado. Establece el elemento especificado de la matriz Array
actual en el valor especificado.
Sort Sobrecargado. Ordena los elementos en objetos Array unidimensionales.
ToString Devuelve un objeto String que representa al objeto Object actual.

Métodos protegidos

Finalize (se hereda de Reemplazado. Permite que un objeto Object intente liberar recursos y
Object) realizar otras operaciones de limpieza antes de que el objeto Object sea
reclamado por el recolector de elementos no utilizados.
En C# y C++, los finalizadores se expresan mediante la sintaxis del destructor.
MemberwiseClone Crea una copia superficial del objeto Object actual.
(se hereda de Object)

Implementaciones de interfaces explícitas

[Link] Implementa [Link]. Siempre inicia una excepción NotSupportedException.

[Link] Establece todos los elementos de Array en cero, false o una referencia nula
(Nothing en Visual Basic), en función del tipo de elemento.
[Link] Determina si un elemento se encuentra en Array.
[Link] Busca el objeto especificado y devuelve el índice de la primera aparición dentro
de la instancia unidimensional actual.
[Link] Implementa [Link]. Siempre inicia una excepción NotSupportedException.
[Link] Implementa [Link]. Siempre inicia una excepción NotSupportedException.
[Link] Implementa [Link]. Siempre inicia una excepción NotSupportedException.
[Link]. Obtiene el número de elementos incluidos en Array.
[Link]
[Link]. Obtiene o establece el elemento que se encuentra en el índice especificado.
[Link]
 Capítulo 7: Collection and Generics - NameSpaces y Bibliotecas de Clases 239

La clase String
Permite utilizar funciones para manipular cadenas de caracteres muy útiles, a continuación veremos
un cuadro extraído de la ayuda y seguidamente ejemplos de su aplicación:

Constructores públicos

String (Constructor) Sobrecargado. Inicializa una nueva instancia de la clase String.

Campos públicos

Empty Representa la cadena vacía. Este campo es de sólo lectura.

Compatible con .NET
Compact Framework.

Propiedades públicas

Chars Obtiene el carácter situado en una posición especificada en la instancia en

cuestión. En C#, esta propiedad es el indizador de la clase String.
Length Obtiene el número de caracteres de la instancia en cuestión.

Métodos públicos

Clone Devuelve una referencia a la instancia de String.

Compare Sobrecargado. Compara dos objetos String especificados.
CompareTo Sobrecargado. Compara la instancia en cuestión con un objeto especificado.
Concat Sobrecargado. Concatena una o más instancias de String o las representaciones
de tipo String de los valores de una o más instancias de Object.
Copy Crea una nueva instancia de String con el mismo valor que una String
especificada.
CopyTo Copia un número especificado de caracteres situados en una posición
especificada de la instancia en una posición determinada de una matriz de
caracteres Unicode.
EndsWith Determina si el final de la instancia en cuestión coincide con el objeto String
especificado.
Equals Sobrecargado. Reemplazado. Determina si dos objetos String tienen el
mismo valor.
Format Sobrecargado. Reemplaza los elementos de formato de un objeto
String especificado por el equivalente textual del valor de un objeto
correspondiente.
GetEnumerator Recupera un objeto que puede iterar los caracteres individuales de la
instancia en cuestión.
GetHashCode Reemplazado. Devuelve el código hash de esta instancia.
GetType (se Obtiene el objeto Type de la instancia actual.
hereda de Object)
GetTypeCode Devuelve TypeCode para la clase String.
240 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

IndexOf Sobrecargado. Devuelve el índice de la primera aparición de un objeto

String, o de uno o más caracteres de la instancia en cuestión.
IndexOfAny Sobrecargado. Devuelve el índice de la primera aparición en la instancia de
un carácter de una matriz de caracteres Unicode especificada.
Insert Inserta una instancia especificada de String en una posición de índice
especificada de la instancia.
Intern Recupera la referencia del sistema al objeto String especificado.
IsInterned Recupera una referencia a un objeto String especificado.
Join Sobrecargado. Concatena un objeto String separador especificado entre
cada uno de los elementos de una matriz String especificada, generando
una sola cadena concatenada.
LastIndexOf Sobrecargado. Devuelve la posición de índice de la última aparición de un
carácter Unicode especificado o de un objeto String en la instancia.
LastIndexOfAny Sobrecargado. Devuelve la posición de índice de la última aparición en
la instancia de uno o varios caracteres especificados de una matriz de
caracteres Unicode.
PadLeft Sobrecargado. Alinea a la derecha los caracteres de la instancia e inserta a
la izquierda espacios en blanco o un carácter Unicode especificado hasta
alcanzar la longitud total especificada.
PadRight Sobrecargado. Alinea a la izquierda los caracteres de la cadena e inserta
a la derecha espacios en blanco o un carácter Unicode especificado hasta
alcanzar la longitud total especificada.
Remove Elimina un número de caracteres especificado de la instancia a partir de una
posición especificada.
Replace Sobrecargado. Reemplaza todas las apariciones de un carácter Unicode o un
objeto String en la instancia por otro carácter Unicode u otro objeto String.
Split Sobrecargado. Identifica las subcadenas de la instancia que están
delimitadas por uno o varios caracteres especificados en una matriz, y las
coloca después en una matriz de elementos String.
StartsWith Determina si el principio de la instancia coincide con el objeto String
especificado.
Substring Sobrecargado. Recupera una subcadena de la instancia.
ToCharArray Sobrecargado. Copia los caracteres de la instancia en una matriz de
caracteres Unicode.
ToLower Sobrecargado. Devuelve una copia de String en minúsculas.
ToString Sobrecargado. Reemplazado. Convierte el valor de la instancia en un objeto
String.
ToUpper Sobrecargado. Devuelve una copia de String en mayúsculas.
Trim Sobrecargado. Quita todas las apariciones de un conjunto de caracteres
especificados desde el principio y el final de la instancia.
TrimEnd Quita todas las apariciones de un conjunto de caracteres especificado en
una matriz del final de esta instancia.
TrimStart Quita todas las apariciones de un conjunto de caracteres especificado en
una matriz del principio de esta instancia.
 CAPÍTULO

8
Serialización
y Servicios Windows
 CAPÍTULO

8 Serialización
y Servicios Windows
SERIALIZACION
Conceptos
Muchas aplicaciones necesitan almacenar o transferir data almacenada en objetos. Para realizar estas
tareas tan simples como sea posible, el Framework .NET incluye varias técnicas de serialización.

Esas técnicas convierten objetos en binarios, Simple Object Access Protocol (SOAP), o documentos
XML que pueden ser fácilmente almacenados, transferidos y recuperados.

La serialización es el proceso de convertir el estado de un objeto en un formato que se pueda almacenar

o transportar. El complemento de serialización es deserialización, que convierte una secuencia en un
objeto. Juntos, estos procesos permiten almacenar los datos y transferirlos con facilidad.

Definiciones Genéricas
La serialización es el proceso mediante el cual se convierte un objeto o un gráfo de objetos en una
secuencia lineal de bytes para su almacenamiento o transmisión a otra ubicación.

La deserialización es simplemente el proceso inverso a la serialización, mediante el cual se recoge la

información almacenada y se vuelven a recrear los objetos originales.

Otras definiciones
La serialización consiste en un proceso de codificación de un Objeto en un medio de almacenamiento
(como puede ser un archivo, o un buffer de memoria) con el fin de transmitirlo a través de una conexión
en red como una serie de bytes o en un formato humanamente más legible como XML. La serie de
bytes o el formato pueden ser usados para crear un nuevo objeto que es idéntico en todo al original,
incluido su estado interno (por tanto, el nuevo objeto es un clon del original). La serialización es un
mecanismo ampliamente usado para transportar objetos a través de una red, para hacer persistente
un objeto en un archivo o base de datos, o para distribuir objetos idénticos a varias aplicaciones o
localizaciones.

En matemáticas y en ciencias de la computación, un grafo es el objeto abstracto básico de estudio en

teoría de los grafos. Informalmente, un grafo se concibe y se representa como un conjunto de objetos
llamados vértices o nodos unidos por enlaces llamados aristas. Las aristas pueden tener dirección
(grafo dirigido).
244 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

NET Framework representa dos tecnologías serializando:

La serialización binaria conserva fidelidad de tipo, que es útil para conservar el estado de un objeto
entre las invocaciones diferentes de una aplicación. Por ejemplo, puede compartir un objeto entre
distintas aplicaciones si lo serializa en el Portapapeles. Puede serializar un objeto en una secuencia,
un disco, la memoria, a través de la red, etc. La comunicación remota utiliza la serialización para pasar
objetos “por valor” de un equipo o dominio de aplicación a otro.

La serialización XML serializa sólo propiedades públicas y campos y no conserva la fidelidad de tipo.
Esto es útil si se desea proporcionar o utilizar los datos sin restringir la aplicación que utiliza los datos.
Dado que XML es un estándar abierto, es una opción atractiva para compartir los datos por el Web.
SOAP es igualmente un estándar abierto, que lo convierte en una opción atractiva.

El espacio de nombres [Link] contiene clases que se pueden utilizar para

serializar y deserializar objetos.

Iserializable
Permite que un objeto controle su propia serialización y deserialización.

SerializationInfo
Almacena todos los datos necesarios para serializar o deserializar un objeto.

IDeserializationCallback
Indica que una clase debe recibir una notificación cuando ha finalizado la deserialización de todo el
gráfo de objetos.
 Capítulo 8: Serialización y Servicios Windows 245

OnSerializingAttribute
Cuando se aplica a un método, especifica que se produce una llamada al método antes de la serialización
de un objeto.

OnSerializedAttribute
Cuando se aplica a un método, especifica que la llamada al método se produce después de la
serialización de un gráfico de objetos.

OnDeserializingAttribute
Cuando se aplica a un método, especifica que la llamada al método se produce durante la deserialización
de un objeto.

OnDeserializedAttribute
Cuando se aplica a un método, especifica que se produce una llamada al método inmediatamente
después de la deserialización del objeto.

¿Cómo son los objetos serializados utilizando BinaryFormatter y SoapFormatter?

Para determinar el formato de serialización de objetos, usted necesita utilizar un formateador.
Un formateador tiene la obligación de indicar la forma en que desea dar formato a los datos que
se van a salvar para deserialization. Puede almacenar estos datos en una ubicación persistentes y,
posteriormente, restaurar de vuelta a su estado original.

El. NET Framework proporciona dos clases de formateador, BinaryFormatter y SoapFormatter. Ambas
clases proporcionan métodos para serialización y deserialization.

BinaryFormatter genera un flujo de compactos cuando serializar un objeto. Por tanto, BinaryFormatter
es útil para el almacenamiento con el stream.

SoapFormatter genera una corriente en formato SOAP cuando serializa un objeto. Al utilizar la clase
SoapFormatter para serialización en aplicaciones que abarcan heterogéneos entornos.

BinaryFormatter produce un flujo más compacto de bytes que SoapFormatter.

SoapFormatter se utiliza generalmente para la interoperabilidad entre plataformas.

Serialización en formato Binario

El espacio de nombres [Link] Serializa o deserializa un objeto
o todo un gráfo de objetos conectados, en formato binario.

La clase BinaryFormatter:
• Está ubicado en el nombre de [Link]
• Serializes y deserializes un objeto en formato binario.
• Serializes y deserializes un objeto gráfico o de todo el gráfico de objetos conectados.
246 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Esto le ayuda a captar la totalidad de un objeto para su utilización en otro proceso. Por ejemplo, usted
puede serializar sólo una silla o quizás serializar todo un conjunto comedor.
• Serializes todos los miembros de un objeto, tales como las propiedades y las enumeraciones,
incluidos los miembros privados. Esto permite BinaryFormatter para almacenar todos los datos de
estado.

Ejemplo Aplicación de la clase BinaryFormatter

El siguiente código muestra muestra la implementación de la clase BinaryFormatter. El código define
una clase llamada a BinaryFormatterDemo para demostrar serialización y deserialization mediante el
uso de la clase BinaryFormatter.

El código crea un objeto de colección ArrayList de colores para guardar los nombres de colores y también
añade cuatro colores para la colección. El código utiliza la clase BinaryFormatter para escribir el estado
del objeto ArrayList a un fichero llamado [Link] mediante el uso de la serializar método de la clase
BinaryFormatter. Después de serializing ArrayList, el código restaura la serie de datos de la Colors.
dat archivo, de vuelta a la forma de un objeto mediante el uso de la Método Deserialize de la clase
BinaryFormatter, y crea un nuevo nombre ArrayList colors2. El código finalmente muestra el contenido de
la recién creada serie, colors2, a comprobar si los datos no es deserialized en el formato correcto.

Imports System
Imports [Link]
Imports [Link]
Class BinaryFormatterDemo
Public Shared Sub Main()
Dim colors As ArrayList = New ArrayList
[Link](“Red”)
[Link](“Blue”)
[Link](“Green”)
[Link](“Yellow”)
Dim fs As FileStream = New FileStream(“C:\[Link]”, _
[Link])
SerializeColors(colors, fs)
[Link]()
fs = New FileStream(“C:\[Link]”, [Link])
Dim colors2 As ArrayList = DeserializeColors(fs)
[Link]()
If (Not (colors2) Is Nothing) Then
For Each color As String In colors2
[Link](“ {0}”, color)
Next
End If
[Link](“Press ENTER to exit...”)
[Link]()
End Sub

Ahora realizaremos las subrutinas siguientes

Private Shared Sub SerializeColors(ByVal arl As ArrayList, _

ByVal fs As FileStream)
Dim formatter As BinaryFormatter = New BinaryFormatter
Try
[Link](fs, arl)
[Link](“Serialization - OK”)
Catch ex As Exception
[Link](“Unable to serialize to binary format”)
[Link](“ {0}”, [Link])
End Try
End Sub
 Capítulo 8: Serialización y Servicios Windows 247

Private Shared Function DeserializeColors(ByVal fs As FileStream) _

As ArrayList
Dim formatter As BinaryFormatter = New BinaryFormatter
Dim arl As ArrayList = Nothing
Try
arl = CType([Link](fs), ArrayList)
[Link](“Deserialization - OK”)
Catch ex As Exception
[Link](“Unable to deserialize from binary format”)
[Link](“ {0}”, [Link])
End Try
Return arl
End Function

Otro Ejemplo de Serializacion Binaria

Bueno realicemos el primer ejemplo de una serialización en formato binario, para este ejemplo
utilizaremos una aplicación de consola, para poder notar mucho mejor las características de la
serialización.

Declaración de la namespace con los cuales se desea trabajar

Imports [Link]
Imports [Link]
Imports [Link]
Imports [Link]

Ahora ponemos el programa principal donde se invocara a la función serializar

Sub Main()
Serialize()
[Link]()
Deserialize()
[Link]()
End Sub

Ahora hacemos la función de serializar

Sub Serialize()
‘ Create a hashtable of values that will eventually be serialized.
Dim addresses As New Hashtable
[Link](“Fatima”, “Jr. Las Gardenias 453, Lince, Fono 4403356”)
[Link](“Iliana”, “Calle Ayacucho 234, Surco., Fono 2523652”)
[Link](“Zoila”, “jr. Huarochiri, Miraflores, Fono 93383491”)
‘ To serialize the hashtable (and its key/value pairs),
‘ you must first open a stream for writing. In this case, use a file stream.
Dim fs As New FileStream(“c:\[Link]”, [Link])
‘ Construct a BinaryFormatter and use it to serialize the data to the stream.
Dim formatter As New BinaryFormatter
Try
[Link](fs, addresses)
[Link](“Los datos Ingresados han sido serializados”)
Catch e As SerializationException
[Link](“Failed to serialize. Reason: “ & [Link])
Throw
Finally
[Link]()
End Try
End Sub
248 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ahora hacemos la función para Deserializar

Sub Deserialize()
‘ Declare the hashtable reference.
Dim addresses As Hashtable = Nothing
‘ Open the file containing the data that you want to deserialize.
Dim fs As New FileStream(“c:\[Link]”, [Link])
Try
Dim formatter As New BinaryFormatter
‘ Deserialize the hashtable from the file and
‘ assign the reference to the local variable.
addresses = DirectCast([Link](fs), Hashtable)
Catch e As SerializationException
[Link](“Failed to deserialize. Reason: “ & [Link])
Throw
Finally
[Link]()
End Try
‘ To prove that the table deserialized correctly, display the key/value pairs.
Dim de As DictionaryEntry
For Each de In addresses
[Link](“{0} lives at {1}.”, [Link], [Link])
Next
End Sub

Ejemplo de Serializacion Binaria en una Aplicación Windows

Crear un formulario que me permita serializar y deserializar un formulario

Propiedades de los controles

Control Propiedades Valor

Label Text Mensaje
Label Text Archivo
Textbox (name) txtMensaje
Textbox (name) txtArchivo
Button (name) btnSerializa
text Serializacion
Button (name) btnDeserializa
text Deserealizacion
 Capítulo 8: Serialización y Servicios Windows 249

Empecemos a codificar, para poder empezar la Serializacion:

Imports [Link]
Imports [Link]
Imports [Link]

Public Class Form1

Private Sub btnSerializa_Click(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
Dim data As String = [Link]
‘ Cree un archivo para que la data sea grabada dentro de el
Dim fs As FileStream = New FileStream([Link], [Link])
‘ Cree un Objeto BinaryFormatter para realizar la serialización
Dim bf As BinaryFormatter = New BinaryFormatter
‘ Use el objeto BinaryFormatter para serializar la data dentro del archivo
[Link](fs, data)
‘ Cierre el archivo
[Link]()
[Link] = “”
End Sub

Private Sub btnDeserealiza_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
‘Proceso de deserealizacion de la data
‘ Abrir el archivo para leer la data almacenada en el
Dim fs1 As FileStream = New FileStream([Link], [Link])
‘ Crear un objeto BinaryFormatter para realizar la deserealizacion
Dim bf1 As BinaryFormatter = New BinaryFormatter
‘ crear el objeto para almacenar la data deserealizada
Dim data1 As String = “”
‘ Use el objeto BinaryFormatter para deserealizar la data desde el archivo
data1 = CType([Link](fs1), String)
‘ Cierrre el archivo
[Link]()
‘ Mostrara la data String deserealizada
[Link](“el mensaje deserealizado es: “ & data1, “Mensaje Deserializado”)
End Sub

SERIALIZACIÓN XML
El espacio de nombres [Link] contiene clases que se utilizan para serializar objetos
en secuencias o documentos con formato XML

La clase SoapFormatter:
Está ubicado en el nombre de [Link]

Serializes y deserializes un objeto en formato SOAP. SOAP es un especializados XML gramática

destinados a facilitar su transporte de datos a través de la Web.
250 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Serializes y deserializes un objeto o todo el gráfico de objetos conectados a formato SOAP . Esto le
ayuda a captar la totalidad de un objeto para su utilización en otro proceso. En el contexto de un
ejemplo de un mobiliario, la clase SoapFormatter le permite serializar sólo una silla o quizás serializar
todo el conjunto del comedor.

Serializes sólo los miembros de un objeto que se declaran como Serializable. Si un miembro se declara
NotSerializable, no se va a utilizar en esta clase.

Serializes sólo los miembros de un objeto que se encuentren públicos.

Ejemplo de Serializacion SoapFormatter

El siguiente código muestra muestra la implementación de la clase SoapFormatter en Visual Basic 10.

Ejemplo de Serializacion Sopa en una Aplicación de Consola

Imports System
Imports [Link]
Imports [Link]
Imports [Link]
Class SoapFormatterDemo

Public Shared Sub Main()

Dim colors As New ArrayList()
[Link](“Red”)
[Link](“Blue”)
[Link](“Green”)
[Link](“Yellow”)
Dim fs As New FileStream(“C:\[Link]”, [Link])
SerializeColors(colors, fs)
[Link]()
fs = New FileStream(“C:\[Link]”, [Link])
Dim colors2 As ArrayList = DeserializeColors(fs)
[Link]()
If Not colors2 Is Nothing Then
For Each color As String In colors2
[Link](“ {0}”, color)
Next
End If
[Link](vbNewLine & “Press ENTER to exit...”)
[Link]()
End Sub

Crearemos la subrutina para deserializar respetando un formato de Deserializacion Soap

Private Shared Sub SerializeColors(ByVal arl As ArrayList, ByVal fs As FileStream)

Dim formatter As New SoapFormatter
Try
[Link](fs, arl)
[Link](“Serialization - OK”)
Catch ex As Exception
[Link](“Unable to serialize to Soap format”)
[Link](“ {0}”, [Link])
End Try
End Sub
 Capítulo 8: Serialización y Servicios Windows 251

Ahora desarrollaremos la función de Deserializacion

Private Shared Function DeserializeColors(ByVal fs As FileStream) _

As ArrayList
Dim formatter As New SoapFormatter
Dim arl As ArrayList = Nothing
Try
arl = CType([Link](fs), ArrayList)
[Link](“Deserialization - OK”)
Catch ex As Exception
[Link](“Unable to deserialize from Soap format”)
[Link](“ {0}”, [Link])
End Try
Return arl
End Function

Ejemplo de Serializacion de tipo XML

Creamos nuestro primer ejercicio con una serialización XML

Imports [Link]
Imports [Link]
Imports [Link]
‘Hacer referencia a este namespace(Menu Proyecto, Agregar Referencia)
Imports [Link]
Module Module1
Sub Main()
Serialize()
Deserialize()
[Link]()
End Sub

Ahora empecemos a desarrollar los procesos para Serializar y Deserializar

Sub Serialize()
‘Crea un hastable de los valores que serán eventualmente serializados .
Dim addresses As New Hashtable
[Link](“Fatima”, “Jr. Las Gardenias 453, Lince, WA 98052”)
[Link](“Iliana”, “Calle Ayacucho 234, Surco., PA 19116”)
[Link](“Zoila”, “jr. Huarochiri, Miraflores, CA 94301”)
‘Para serializar el hashTable (y sus llave/del valor), usted debe primero
‘abrir una archivo para [Link] un stream del archivo aquí.
Dim fs As New FileStream(“c:\[Link]”, [Link])
‘ Construya un SoapFormatter y utilícelo para serializar los datos para el
Stream
Dim formatter As New SoapFormatter
Try
[Link](fs, addresses)
Catch e As SerializationException
[Link](“Fallo la Serializacion. Razon: “ & [Link])
Throw
Finally
[Link]()
End Try
End Sub
252 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Sub Deserialize()
‘ Declare un hashtable como referencia.
Dim addresses As Hashtable = Nothing
‘Abro el archivo que contiene la data a deserializar
Dim fs As New FileStream(“c:\[Link]”, [Link])
Try
Dim formatter As New SoapFormatter
‘Deserialize el hashtable del archivo y asigna la referencia a la variable
local.
addresses = DirectCast([Link](fs), Hashtable)
Catch e As SerializationException
[Link](“Fallo la Serializacion. Reazon: “ & [Link])
Throw
Finally
[Link]()
End Try
‘ To prove that the table deserialized correctly, display the key/value pairs
to the console.
Dim de As DictionaryEntry
For Each de In addresses
[Link](“{0} lives at {1}.”, [Link], [Link])
Next
End Sub

Ejemplo de Serializacion XML en una Aplicación Windows

Hacer un formulario que me permita ingresar un nombre, dirección, teléfono y email y este será serial
izado con un formato XML, empecemos a desarrollar este ejercicio:
 Capítulo 8: Serialización y Servicios Windows 253

Propiedades de los Controles del Formulario

Controles Propiedades Valores

Label Text Nombre :
Label Text Direccion:
Label Text Telefono:
Label Text E-Mail:
Button (name) btnMostrar
Text Mostrar
Button (name) btnAceptar
Text Aceptar
Textbox (name) txtNombre
Textbox (name) txtDireccion
Textbox (name) txtTelefono
Textbox (name) txtEmail

Ahora empecemos a ver la codificación para el funcionamiento del formulario:

Imports [Link]
Imports [Link]
Public Class Form1
Public Sub New()
[Link]()
‘El Diseñador de Windows Forms requiere esta llamada.
InitializeComponent()

‘Agregar cualquier inicialización después de la llamada a InitializeComponent()

Dim fa As New FileInfo([Link] & “[Link]”)
If [Link] Then
OpenFileContactosXML()
Else
CreateFileContactosXML()
End If
End Sub

Se construye la función que va a crear, utilizando una serialización XML, la función es

CreateFileContactosXML

Private Sub CreateFileContactosXML()

‘Crear el Objeto y poblarlo
Dim ObjContactos As New Contactos
[Link] = [Link]
[Link] = [Link]
[Link] = [Link]
[Link] = [Link]
‘Crea un objeto serializaco para la clase Contactos
Dim ObjWriter As New [Link](GetType(Contactos))
‘Crear un objeto File de tipo StreamWriter para almacenar el documento XML
Dim objFile As New StreamWriter(“c:\[Link]”)
‘Serializar y crear el documento XML
[Link](objFile, ObjContactos)
‘Cerrar el archivo
[Link]()
End Sub
254 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Hacer una función que permita abrir el archivo XML

‘OpenFileContactosXML
‘Abrir archivo XML y Mostrarlo en los controles dela forma.
Private Sub OpenFileContactosXML()
‘Leer un archivo XML y cargarlo en un objeto
‘ Dim xmlReader As New XmlTextReader([Link] +
“[Link]”)
Dim xmlReader As New XmlTextReader(“c:\[Link]”)
‘Crear un objeto para deserializar el archivo XML
Dim Reader As New [Link](GetType(Contactos))
‘Deserialziar el archivo xml y cargarlo en un objeto
Dim ContactosRead = [Link](xmlReader)
‘Cargar los datos en la forma.
[Link] = [Link]
[Link] = [Link]
[Link] = [Link]
[Link] = [Link]
‘Cerrar Archivo XML
[Link]()
End Sub

Ahora trabajamos los botones

Private Sub btnAceptar_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) _
Handles [Link]
‘Crear archivo XML con informacion del contacto
CreateFileContactosXML()
[Link]() : [Link]() : [Link]() : txtEmail.
Clear()
‘[Link]()
End Sub

Private Sub btnMostrar_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) _
Handles [Link]
OpenFileContactosXML()
End Sub

¿CUÁLES SON LOS ATRIBUTOS SERIALIZACIÓN XML?

Introducción
Usted puede controlar la serialización XML de un objeto o crear un flujo XML de la misma serie de
clases mediante el uso de atributos.

Como resultado de ello, serialización XML atributos determinar el formato XML resultante para cada
clase de miembro asociado a un atributo. La serialización XML atributos contienen propiedades que
proporcionan información a la clase XmlSerializer sobre cómo asignar un objeto a formato XML.

Estas propiedades como definir nombres XML, limitar el alcance del atributo a un determinado tipo
de datos, especifique el tipo correspondiente a un esquema XSD, el control de la forma del XML
generados, y definir si la creación de XML para referencias nula.

La serialización XML atributos son los atributos que le ayudan a generar la costumbre y formato XML
atributos que le ayudan a generar la costumbre formato SOAP.
 Capítulo 8: Serialización y Servicios Windows 255

Atributos Descripción
XmlAnyAttributeAttribute XmlAnyAttributeAttribute contiene datos arbitrarios, que se
envía como parte de un documento XML, como el atributo
de un elemento. El propósito de este atributo es la creación
de un campo o de los bienes a recibir atributos XML que no
mapea a cualquier campo o propiedades de la clase.
XmlAnyElementAttribute XmlAnyElementAttribute contiene datos arbitrarios que es
enviada como parte de un documento XML en forma de un
elemento. El objetivo de este atributo es la creación de un
campo o de los bienes a recibir esos XML elementos que no
mapa a cualquier campo o propiedades de la clase.
XmlArrayAttribute XmlArrayAttribute está diseñado para controlar la serialización
de arrays. Este atributo indica XmlSerializer a serializar una clase
en particular como una matriz de elementos XML. Mediante
la aplicación de XmlArrayAttribute, puede determinar las
propiedades de la XML resultante elemento y también cambiar
el nombre del XML.
XmlArrayItemAttribute XmlArrayItemAttribute está diseñado para controlar la
serialización de arrays. Permite que la serialización de
clases derivadas, y se especifican los derivados de tipos que
XmlSerializer puede colocar en una serie matriz.
XmlAttributeAttribute XmlAttributeAttribute especifica que XmlSerializer serializes
la clase como un atributo XML. Puede asignar
XmlAttributeAttribute únicamente a los ámbitos públicos o
públicos propiedades que devuelvan un valor o conjunto de
valores, que pueden ser asignadas a uno de los tipos XSD.
XmlChoiceIdentifierAttribute XmlChoiceIdentifierAttribute especifica que el miembro
puede ser detectados mediante una enumeración. Esto le
permite establecer un objeto que una secuencia como un
conjunto de opciones, tales como una lista.
XMLChoiceIdentifier le permite especificar qué elemento
de la lista fue elegido. XmlChoiceIdentifierAttribute le
permite asignar una enumeración valor a cada instancia de
los miembros. Tú puede crear usted mismo la enumeración
o generar una enumeración de utilizar el XML Schema
Definition Tool ([Link]).
XmlElementAttribute XmlElementAttribute especifica que un campo público o
propiedad representa un elemento XML cuando XmlSerializer,
serializes o deserializes el objeto que lo contiene.
XmlEnumAttribute XmlEnumAttribute controla cómo la clase XmlSerializer
serializa una enumeración miembro. Puede utilizar
XmlEnumAttribute a cambiar la forma en que XmlSerializer
genera o se reconoce una enumeración miembro durante
serialización o deserialization, respectivamente.
256 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

XmlIgnoreAttribute XmlIgnoreAttribute instruye el método a serializar de la clase

XmlSerializer, no serializa el campo público o la propiedad
pública de lectura / escritura. Si se aplica a cualquier miembro
XmlIgnoreAttribute de una clase, la clase XmlSerializer hace
caso omiso de los miembros cuando serializa o deserializa una
instancia de la clase.
XmlIncludeAttribute XmlIncludeAttribute permite a la clase XmlSerializer
a reconocer un tipo particular cuando se serializa o
deserializa un objeto. Esto tipo podría ser cualquier clase
derivada que usted ha definido para serialización. Al aplicar
XmlIncludeAttribute, que especifique el tipo de la clase
derivada. Durante la serialización de objetos que incluyen
tanto la base y la clase derivada, el XmlSerializer clase pueden
reconocer dos tipos de objetos.
XmlRootAttribute XmlRootAttribute controla la serialización XML del atributo
destino como un elemento raíz XML. Puede aplicar
XmlRootAttribute a una clase, estructura, enumeración o
interfaz. Cada XML el documento tiene un único elemento raíz
que contiene todos los demás elementos. XmlRootAttribute le
permite controlar la generación de la raíz elemento mediante
el establecimiento de propiedades en el XmlSerializer clase.
Esto le ayuda a tener un mejor control sobre la salida de su y
el documento XML que contiene.
XmlTextAttribute XmlTextAttribute indica a XmlSerializer que el miembro
especifico debe ser tratado como texto XML durante la
serialización deserialization o del objeto. XmlSerializer
traduce el valor del miembro en XML texto y codifica el valor
en el contenido de un elemento XML.
XmlTypeAttribute XmlTypeAttribute controla el esquema XML que se genera
cuando el atributo genera una secuencia de la XmlSerializer
la clase XmlTypeAttribute puede aplicarse a una clase,
estructura, enumeración, o interfaz de declaración.
XmlTypeAttribute especifica el nombre y los nombres de tipo
XML. Puede utilizar este atributo con el [Link] herramienta
para generar un archivo XSD.

Ejemplo de Serializacion de tipo XML

Aplicación de atributos personalizados para el formato XML.

El siguiente código pone de manifiesto la aplicación de los atributos de código XML personalizado
formato en Visual Basic. El código muestra cómo aplicar serialización XML atributos y su funcionalidad.
El código muestra cómo estos atributos el formato XML generados por la serialización.

El código contiene una clase llamada Company, que almacena la información de la empresa y ha
algunos ámbitos público y una serie sobre el terreno, que contiene objetos de otra clase llamada
Empleado.
 Capítulo 8: Serialización y Servicios Windows 257

En el principal método, crea y inicializa un objeto Empresa y, a continuación, serializa a un archivo XML
llamado [Link]. Por último, usted deserialize en otra objeto de Empresa.

Imports System
Imports [Link]
Imports [Link]
Imports [Link]
Public Class Employee
Public Name As String
End Class
Public Class Company
<XmlAttribute()> Public CompanyName As String
<XmlAnyAttribute()> Public XAttributes() As XmlAttribute
<XmlAnyElement()> Public XElements() As XmlElement
<XmlElement(ElementName:=”Members”)> Public Employees() As Employee
Public Shared Sub Main()
Dim filename As String = “c:\[Link]”
Dim serializer As XmlSerializer = New XmlSerializer(GetType(Company))
Dim writer As TextWriter = New StreamWriter(filename)
Dim com As Company = New Company()
[Link] = “ABC InfoSystems”
Dim emp1 As Employee = New Employee()
Dim emp2 As Employee = New Employee()
[Link] = “Fatima”
[Link] = “Gianluc”
[Link] = New Employee() {emp1, emp2}
[Link](writer, com)
[Link]()
Dim fs As FileStream = New FileStream(filename, [Link])
Dim cmp As Company = CType([Link](fs), Company)
[Link]([Link])
For Each e As Employee In [Link]
[Link](“ {0}”, [Link])
Next
[Link]()
[Link](“Press ENTER to exit...”)
[Link]()
End Sub
End Class

Atributos de costumbre formato SOAP

Puede aplicar estos atributos serialización XML para el control de la codificacion de la serialización
SOAP.

Estos atributos son un conjunto especial de atributos que se encuentran en la [Link].

Estos atributos se aplican en clases y miembros de las clases. Entonces, estos atributos usa XmlSerializer
al serializar instancias de la clase o clases.

La siguiente tabla describe los atributos personalizados para el formato SOAP.

258 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Atributos Descripcion
SoapAttributeAttribute SoapAttributeAttribute especifica que la clase XmlSerializer necesarias
para serializar el miembro de clase en un atributo codificado SOAP.
SoapAttributeAttribute se aplica a un ámbito público para especificar
que XmlSerializer serialize el campo como un atributo XML. Esto es útil
para un objeto SOAP para poder recibir los insumos adecuados. Además,
esto le permite al cliente serializar el objeto con un atributo, por ejemplo
preferida para establecer SoapAttribute de Preferencia y serializar.
SoapElementAttribute SoapAttributeAttribute especifica que la clase XmlSerializer necesarias
para serializar el Miembro de clase en un atributo codificado SOAP .
SoapAttributeAttribute se APLICA a un Ámbito público para especificar
que XmlSerializer pueda serializar el campo como un atributo XML. Esto
es útil para un objeto SOAP para poder RECIBIR los insumos adecuados.
Además, esto le permite al cliente serializar el objeto con un atributo,
por ejemplo preferida para establecer SoapAttribute de PREFERENCIA y
serializar.
SoapEnumAttribute SoapEnumAttribute controla cómo XmlSerializer serializa un miembro de
tipo enumeracion. Se puede usar para cambiar el SoapEnumAttribute,
la forma en que XmlSerializer genera o se reconoce un tipo miembro
enumeración durante serialización o deserialization, respectivamente
SoapIgnoreAttribute SoapIgnoreAttribute puede aplicarse A CUALQUIER MIEMBRO de la
clase que usted XmlSerializer quieren hacer caso omiso cuando una
Instancia de la clase es seriados. SoapIgnoreAttribute instruye a la clase
XmlSerializer no serializar el Ámbito público o PÚBLICO DE lectura /
escritura EL VALOR DE LA PROPIEDAD.
SoapIncludeAttribute SoapIncludeAttribute permite a la clase XmlSerializer a reconocer un
determinado tipo cuando va a serializar o deserializar como un objeto
codificado SOAP XML. Al aplicar SoapIncludeAttribute, que especifique el
tipo de la clase derivada. Durante la serialización de objetos que incluyen
tanto la base y la clase derivada, XmlSerializer puede entonces reconocer
ambos tipos de objetos.
SoapTypeAttribute SoapTypeAttribute controla el esquema generado por XmlSerializer
cuando una clase, ejemplo como una secuencia codificada SOAP-XML.

Ejemplo Aplicación de atributos personalizados para el formato SOAP

El siguiente código muestra se pone de manifiesto la aplicación de atributos personalizados para SOAP
que se diseñara en formato en Visual Basic.

El código muestra cómo utilizar atributos de serialización XML, como SoapElement y SoapAttribute
para generar la personalizaciones en formato SOAP la cual resultara durante serialización XML.

El código define una clase llamada Compañía y se aplica los atributos de serialización XML que realiza
a sus miembros para el formato XML resultado de la serializacion de la clase Compañía

El principal método inicializa un objeto de Empresa y, a continuación, serializa un Archivo XML llamado
[Link]. Por último, existira un método deserializes que se encuentra en la clase Empresa.
 Capítulo 8: Serialización y Servicios Windows 259

Imports System
Imports [Link]
Imports [Link]
Imports [Link]
Imports [Link]
Public Class Company
<SoapAttribute(AttributeName:=”company”)>_
Public CompanyName As String
<SoapElement(ElementName:=”CorporateOffice”)>_
Public CorporateOffice As String
<SoapIgnore()>_
Public CompanyId As String
Public Overrides Function ToString() As String
Dim send As String
send = [Link]
send &= “Company name: “ & [Link]
send &= [Link]
send &= “Corporate Office: “ & [Link]
send &= [Link]
send &= “Company Id: “ & [Link]
Return send
End Function

Ahora realizaremos el proceso principal en el evento Sub Main

Public Shared Sub Main()

Dim filename As String = “c:\[Link]”
Dim myMapping As XmlTypeMapping = _
New SoapReflectionImporter().ImportTypeMapping( _
GetType(Company))
Dim mySerializer As XmlSerializer = New XmlSerializer(myMapping)
Dim myCompany As Company = New Company()
[Link] = “Sanchez S.A.”
[Link] = “90012”
[Link] = “San Isidro”
Dim writer As XmlTextWriter = _
New XmlTextWriter(filename, Encoding.UTF8)
[Link] = [Link]
[Link](“CompanyInfo”)
[Link](writer, myCompany)
[Link]()
[Link]()
Dim reader As XmlTextReader = _
New XmlTextReader(filename)
[Link](“CompanyInfo”)
myCompany = CType([Link](reader), Company)
[Link]()
[Link]()
[Link](myCompany)
[Link]()
[Link](“Press ENTER to exit...”)
[Link]()
End Sub
260 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

SERVICIOS WINDOWS
Clase [Link]
Windows realiza una serie de funciones de forma automática, tales como configurar nuestro PC para
funcionar dentro de nuestra red, reconocer nuevo hardware etc.

Todo ello de forma aparentemente automática, de forma transparente al usuario y todo ello es posible
gracias en gran medida a “los servicios”.

Los servicios son pequeños programas que se ejecutan de forma automática al iniciar Windows y
quedan residentes en memoria, consiguiendo que el máximo posible de situaciones sean resueltas
con la mínima intervención del usuario.

El espacio de nombres [Link] proporciona clases que permiten implementar, instalar

y controlar las aplicaciones de servicios para Windows.

Definición de los Servicios Windows

Los servicios son aplicaciones ejecutables de larga duración que se ejecutan sin interfaz de usuario.
La implementación de un servicio implica la herencia de la clase ServiceBase y la definición de un
comportamiento específico que se ha de procesar al pasar comandos de inicio, detención, pausa y
continuación, así como el comportamiento personalizado y las acciones que se deben adoptar cuando
se cierra el sistema.

ServiceController y ServiceBase
La clase ServiceController permite conectarse a un servicio existente y manipularlo u obtener
información sobre el mismo. Esta clase suele utilizarse en tareas administrativas, y permite iniciar,
detener, pausar, continuar o ejecutar comandos personalizados en un servicio. Mientras que la
clase ServiceBase define el procesamiento que realiza un servicio cuando se ejecuta un comando,
ServiceController es el agente que permite llamar a esos comandos en el servicio.

Enumeraciones
 Capítulo 8: Serialización y Servicios Windows 261

Ejemplo de Servicios Windows

Este ejemplo me permite diseñar un programa que pueda controlar los servicios del Windows desde
visual Studio, el formulario es el siguiente que se creara en el proyecto AdministrarServicios.

Ahora creamos un Proyecto que se llame ServicioWindows y ahí se desarrollaran 2 clases que son
InstallerPruebaSW y PruebaSW

Clase InstallerPruebaSW
Imports [Link]
Imports [Link]
Imports [Link]
<RunInstaller(True)> Public Class InstallerPruebaSW
Inherits [Link]
Private serviceInstaller1 As ServiceInstaller
Private processInstaller As ServiceProcessInstaller
262 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Public Sub New()

‘ Ejemplifican los instaladores de proceso y servicios.
processInstaller = New ServiceProcessInstaller()
serviceInstaller1 = New ServiceInstaller()
‘ Los servicios se ejecutará bajo el sistema
[Link] = [Link]
‘ El servicio se iniciará manualmente
‘ para que se inicie automáticamente, especificar el valor:
‘ [Link]
[Link] = [Link]
‘ Servicename debe ser igual a las clases ServiceBase derivadas.
[Link] = “PruebaSW”
‘ Añadir instaladores para la [Link] Orden no es importante.
[Link](serviceInstaller1)
[Link](processInstaller)
End Sub
End Class

Ahora la Clase PruebaSw, empezamos con las declaraciones

Imports [Link]
Imports [Link]
Private WithEvents temporizador As [Link]
Private intervalo As Integer = 50000
‘ la aplicación que vamos a comprobar
Private aplicación As String
si se debe hacer la comprobación
Private comprobar As Boolean

Ahora empecemos con el código

Protected Overrides Sub OnStart(ByVal args() As String)

‘ Agregar código aquí para iniciar el servicio. Este método debería poner
en movimiento los elementos para que el servicio pueda [Link] args() estarán
los argumentos pasados al servicio. Se indicará en la forma:aplicación [/C] para
iniciar la comprobación de la aplicación indicada
‘ [aplicación] /NC para detener la comprobación
Try
Dim s As String = args(0).Trim
If s <> “” Then
Dim i As Integer
‘ primero averiguamos si se debe o no comprobar
If [Link](“/C”) > -1 Then
comprobar = True
Else
comprobar = False
End If
i = [Link](“/”) ‘ según se haya o no indicado el segundo parámetro
Select Case i
Case -1
‘ no se indica el segundo parámetro debe ser el nombre de
la aplicación
aplicación = s : comprobar = True
Case Is > 0
‘ se indica la aplicación, debe estar antes de la barra
aplicación = [Link](0, i - 1).Trim
End Select
End If
Catch
 Capítulo 8: Serialización y Servicios Windows 263

‘ si se produce un error, no asignar nada, se usarán los valores

anteriores, si hay...
End Try
‘ empezar con un intervalo pequeño para que se inicie el evento del temporizador
‘ nada más empezar, después se asignará el valor configurado
temporizador = New [Link](100)
[Link]()
End Sub

Seguimos con otros procesos

Protected Overrides Sub OnStop()

‘ Agregar código aquí para realizar cualquier anulación necesaria para detener
el servicio.
[Link]()
End Sub

Protected Overrides Sub OnPause()

‘ si se detiene temporalmente el servicio
[Link]()
End Sub
Protected Overrides Sub OnContinue()
‘ si s continúa el servicio, volver a iniciar el temporizador
[Link]()
End Sub

Ahora el Último Procedimiento de esta clase

Private Sub temporizador_Elapsed(ByVal sender As Object, _

ByVal e As [Link]) _
Handles [Link]
‘ deshabilitar temporalmente el timer
[Link] = False
‘ asignar el nuevo valor del temporizador
If intervalo <> [Link] Then
[Link] = intervalo
End If
If comprobar Then
Try
Dim procesos() As Process
Dim nombreProceso As String
‘ el nombre del proceso suele ser el nombre de la aplicación sin la
extensión
nombreProceso = [Link](aplicación)
procesos = [Link](nombreProceso)
If ([Link] = 0 OrElse (procesos Is Nothing)) Then
‘ si no está en ejecución, iniciarlo
‘ Los ejecutables iniciados con un Servicio de Windows
‘ no se muestran: se ejecutan ocultos.
Dim proceso As New Process()
[Link] = aplicación
[Link]()
End If
Catch
End Try
End If
‘ volver a habilitar el timer
[Link] = True
End Sub
264 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ahora empecemos a programar en el formulario

Option Strict On
Imports [Link]
Private servicios() As ServiceController
Private servicio As ServiceController
Private itemActual As ListViewItem
Private Sub Form_Load(ByVal sender As [Link], ByVal e As
[Link]) Handles [Link]
ith serviciosLv
.View = [Link]
.FullRowSelect = True
.GridLines = True
.LabelEdit = False
.HideSelection = False
.[Link]()
.[Link](“Servicio”, 100, [Link])
.[Link](“Estado”, 60, [Link])
.[Link](“Descripción”, 200, [Link])
.[Link](“Tipo de servicio”, 100, [Link])
.[Link](“Equipo”, 70, [Link])
End With
[Link] = False : [Link] = False
[Link] = False : [Link] = False
[Link] = False
[Link] = False
[Link] = “”
[Link] = “”
‘mostrar Procedimiento
mostrarServicios()
End Sub

Empecemos a codificar los botones

Private Sub refrescarBtn_Click(ByVal sender As [Link], _

ByVal e As [Link]) Handles refrescarBtn.
Click
mostrarServicios([Link])
End Sub
Private Sub cerrarBtn_Click(ByVal sender As [Link], _
ByVal e As [Link]) Handles [Link]
Close()
End Sub
Private Sub iniciarBtn_Click(ByVal sender As [Link], _
ByVal e As [Link]) Handles [Link]
Try
[Link]()
comprobarEstado(servicio)
Catch ex As Exception
[Link]([Link], “Error al iniciar el servicio”)
End Try
End Sub
‘
Private Sub iniciarParametrosBtn_Click(ByVal sender As [Link], _
ByVal e As [Link]) Handles
[Link]
Try
If [Link] <> “” Then
Dim args(0) As String
args(0) = [Link]
[Link](args)
 Capítulo 8: Serialización y Servicios Windows 265

Else
[Link]()
End If
comprobarEstado(servicio)
Catch ex As Exception
[Link]([Link], “Error al iniciar el servicio con parámetros”)
End Try
End Sub
Private Sub detenerBtn_Click(ByVal sender As [Link], _
ByVal e As [Link]) Handles detenerBtn.
Click
Try
If [Link] Then
[Link]()
comprobarEstado(servicio)
End If
Catch ex As Exception
[Link]([Link], “Error al detener el servicio”)
End Try
End Sub

Seguimos codificando las botones

Private Sub pausarBtn_Click(ByVal sender As [Link], _

ByVal e As [Link]) Handles [Link]
Try
If [Link] Then
If [Link] = [Link] Then
[Link]()
comprobarEstado(servicio)
End If
End If
Catch ex As Exception
[Link]([Link], “Error al pausar el servicio”)
End Try
End Sub
‘
Private Sub continuarBtn_Click(ByVal sender As [Link], _
ByVal e As [Link]) Handles continuarBtn.
Click
Try
If [Link] Then
If [Link] = [Link] Then
servicio.[Continue]()
comprobarEstado(servicio)
End If
End If
Catch ex As Exception
[Link]([Link], “Error al continuar el servicio”)
End Try
End Sub

Private Sub reiniciarBtn_Click(ByVal sender As [Link], _

ByVal e As [Link]) Handles reiniciarBtn.
Click
If [Link] = [Link] Then
Try
[Link]()
[Link]()
Catch ex As Exception
[Link]([Link], “Error al reiniciar el servicio”)
266 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

End Try
End If
If [Link] = [Link] Then
Try
[Link]()
Catch ex As Exception
[Link]([Link], “Error al reiniciar el servicio”)
End Try
End If
comprobarEstado(servicio)
End Sub

Ahora codificamos el Listview

Private Sub serviciosLv_SelectedIndexChanged(ByVal sender As [Link], _

ByVal e As [Link]) _
Handles [Link]
Try
itemActual = [Link](0)
servicio = DirectCast([Link], ServiceController)
comprobarEstado(servicio)
Catch
itemActual = Nothing
comprobarEstado()
End Try
End Sub
‘
Private Sub mostrarServicios()
mostrarServicios(“”)
End Sub

Ahora crearemos las siguiente subrutinas

Private Sub mostrarServicios(ByVal equipo As String)
Dim i As Integer
Dim lvi As ListViewItem
If equipo = “” Then equipo = “.”
servicios = [Link](equipo)
[Link]()
For i = 0 To [Link] - 1
lvi = [Link](servicios(i).ServiceName)
[Link](servicios(i).[Link])
[Link](servicios(i).DisplayName)
[Link](servicios(i).[Link])
[Link](servicios(i).MachineName)
‘ guardar una referencia del servicio en la propiedad Tag
[Link] = servicios(i)
Next
End Sub

Private Sub comprobarEstado()

[Link] = False
[Link] = False
[Link] = False
[Link] = False
[Link] = False
[Link] = False
End Sub
 Capítulo 8: Serialización y Servicios Windows 267

Ahora seguimos codificando los eventos

Private Sub comprobarEstado(ByVal elServicio As ServiceController)

Dim servStatus As ServiceControllerStatus
[Link] = False : [Link] = False
[Link] = False : [Link] = False
[Link] = False : [Link] = False
‘
Try
servicio = elServicio
[Link]()
servStatus = [Link]
If [Link] Then
[Link] = (servStatus = [Link])
[Link] = (servStatus = [Link])
End If
If [Link] Then
[Link] = (servStatus = [Link])
End If
[Link] = (servStatus = [Link])
[Link] = [Link]
[Link] = [Link]
Catch
‘[Link] = False : ‘[Link] = False
‘[Link] = False : ‘[Link] = False
‘[Link] = False : ‘[Link] = False
End Try
If Not itemActual Is Nothing Then
Try
[Link](1).Text = [Link]
Catch ex As Exception
[Link]([Link], “Error al comprobar el estado del
servicio”)
End Try
End If
End Sub
268 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

INSTRUMENTACIÓN
La definición de Microsoft de WMI Instrumental de administración de Windows (WMI) es un
componente del sistema operativo Windows que permite obtener acceso mediante programación a
información de administración en un entorno empresarial. WMI en .NET Framework se basa en la
tecnología WMI original y permite el mismo desarrollo de aplicaciones y proveedores, además de las
ventajas que ofrece la programación en .NET Framework.

WMI es espectacular. Cualquier información que desees obtener de cualquier sistema windows, WMI
la proporciona, desde el nombre del sistema operativo de una máquina, pasando por la memoria ram
que tiene, las tarjetas de red, configuración de cualquier cosa del sistema, performance, servicios,
tareas, services packs instalados, software instalado, etc.

Arquitectura
La arquitectura de WMI consta de los niveles siguientes:

Los componentes de software cliente realizan operaciones mediante WMI, como leer detalles de
administración, configurar sistemas y realizar suscripciones a eventos.

El administrador de objetos es un intermediario entre los proveedores y los clientes que proporciona
ciertos servicios esenciales, como la publicación y suscripción estándar de eventos, el filtrado de
eventos, motor de consultas y otros servicios.

Bueno, WMI significa Windows Management Instrumentation, o bien, Instrumental de administración

de Windows, y ¿Qué es?, bueno en sí son un conjunto de clases que residen en el sistema operativo...
es increíble, pero WMI está presente de manera nativa desde Windows 2000, ya hace un buen tiempo
de eso, además se le prestó soporte a Windows 9x con redistribuibles que permitían a un servidor
consultar elementos del sistema operativo de manera remota. WMI no nace de la nada y no es algo
que Microsoft haya inventado, WMI es la implementación de Microsoft dentro de Windows de un
estándar llamado WBEM (Web-Based Enterprise Management) que está basado en la definición
de CMI (Common Model Information). CMI provee definiciones para clases de administración que
podemos encontrar prácticamente en cualquier sistema operativo que adopte estos estándares.

Información general sobre WMI .NET

Con el espacio de nombres de .NET Framework [Link], puede desarrollar aplicaciones
en C#, Microsoft® Visual Basic® .NET o Microsoft J# para obtener datos empresariales y automatizar
tareas administrativas mediante Instrumental de administración de Windows (WMI). También puede
desarrollar aplicaciones que proporcionen datos a clases WMI con el espacio de nombres System.
[Link].

Esta guía constituye un suplemento a la información de la guía de programación de .NET Framework y

proporciona información general acerca del uso y la programación de ejemplos de código para clases
en los espacios de nombres [Link] y [Link]. La guía
de programación de .NET Framework contiene toda la información de referencia con respecto a los
espacios de nombres [Link] y [Link].

Las clases .NET Framework que utilizan WMI se encuentran en los espacios de nombres System.
Management y [Link]. Sin embargo, las aplicaciones de código
administrado, basadas en .NET Framework, presentan algunas limitaciones que no tienen las
aplicaciones y los proveedores de WMI original.
 Capítulo 8: Serialización y Servicios Windows 269

La arquitectura de WMI consta de los niveles siguientes:

• Los componentes de software cliente realizan operaciones mediante WMI, como leer detalles de
administración, configurar sistemas y realizar suscripciones a eventos.
• El administrador de objetos es un intermediario entre los proveedores y los clientes que proporciona
ciertos servicios esenciales, como la publicación y suscripción estándar de eventos, el filtrado de
eventos, motor de consultas y otros servicios.
• Los componentes de software de proveedor capturan y devuelven datos activos a las aplicaciones
cliente, procesan llamadas a métodos procedentes de los clientes y vinculan al cliente con la
infraestructura que se está administrando.

Ejemplo de Instrumentación
WMI implementa clases para consultas de información del sistema operativo, se divide en tres grandes
grupos:
Hardware --- Software ---- Sistema Operativo

Bueno, WMI significa Windows Management Instrumentation, o bien, Instrumental de administración

de Windows, y ¿Qué es?, bueno en sí son un conjunto de clases que residen en el sistema operativo...
es increíble, pero WMI está presente de manera nativa desde Windows 2000, ya hace un buen tiempo
de eso, además se le prestó soporte a Windows 9x con redistribuibles que permitían a un servidor
consultar elementos del sistema operativo de manera remota. WMI no nace de la nada y no es algo
que Microsoft haya inventado, WMI es la implementación de Microsoft dentro de Windows de un
estándar llamado WBEM (Web-Based Enterprise Management) que está basado en la definición
de CMI (Common Model Information). CMI provee definiciones para clases de administración que
podemos encontrar prácticamente en cualquier sistema operativo que adopte estos estándares.

Se debe crear un formulario en el cual solo se le anexara un datagrid, el cual quedara de esta manera:
270 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Se declaran las siguientes clases

Imports System
Imports [Link]
Imports [Link]
Imports [Link]
Imports [Link]
Imports [Link]
Imports [Link]
Imports [Link]

Ahora creamos la función GetProcess para poder utilizarla más adelante

Public Shared Function GetProcess() As DataTable
Dim searcher As [Link] = New Management
ObjectSearcher(“Select * From Win32_Process”)
Dim dt As New DataTable()
Dim dr As DataRow
[Link](“Caption”)
[Link](“CreationClassName”)
[Link](“CreationDate”)
[Link](“Description”)
[Link](“ExecutablePath”)
[Link](“ExecutionState”)
[Link](“Handle”)
[Link](“InstallDate”)
[Link](“MaximumWorkingSetSize”)
[Link](“MinimumWorkingSetSize”)
[Link](“Name”)
[Link](“Priority”)
[Link](“ProcessId”)
[Link](“SessionId”)
[Link](“Status”)
[Link](“TerminationDate”)
[Link](“ThreadCount”)
[Link](“WindowsVersion”)
[Link](“WorkingSetSize”)
For Each share As ManagementObject In [Link]()
dr = [Link]()
dr(“Caption”) = share(“Caption”)
dr(“CreationClassName”) = share(“CreationClassName”)
dr(“CreationDate”) = share(“CreationDate”)
dr(“Description”) = share(“Description”)
dr(“ExecutablePath”) = share(“ExecutablePath”)
dr(“ExecutionState”) = share(“ExecutionState”)
dr(“Handle”) = share(“Handle”)
dr(“InstallDate”) = share(“InstallDate”)
dr(“MaximumWorkingSetSize”) = share(“MaximumWorkingSetSize”)
dr(“MinimumWorkingSetSize”) = share(“MinimumWorkingSetSize”)
dr(“Name”) = share(“Name”)
dr(“Priority”) = share(“Priority”)
dr(“ProcessId”) = share(“ProcessId”)
dr(“SessionId”) = share(“SessionId”)
dr(“Status”) = share(“Status”)
dr(“TerminationDate”) = share(“TerminationDate”)
dr(“ThreadCount”) = share(“ThreadCount”)
dr(“WindowsVersion”) = share(“WindowsVersion”)
dr(“WorkingSetSize”) = share(“WorkingSetSize”)
[Link](dr)
Next
Return dt
End Function

Invocamos a la función desde el evento load

Private Sub Form1_Load(ByVal sender As [Link], ByVal e As [Link])
Handles [Link]
[Link] = GetProcess()
End Sub
 CAPÍTULO

9
Trabajando con Email y
Clientes Inteligentes
 CAPÍTULO

9 Trabajando con Email y

Clientes Inteligentes
Creando Emails
Cuando nosotros creamos un mensaje de correo electrónico pueden ser simples o complejas. En su forma
más simple, un mensaje de correo electrónico tiene un remitente, destinatario, asunto, y el cuerpo.

Estos sencillos mensajes se pueden crear con una sola línea de código usando el. NET Framework. En
su forma más compleja, los mensajes de correo electrónico puede tener la costumbre de codificación
de los tipos, múltiples puntos de vista de texto plano y HTML, archivos adjuntos, imágenes incrustadas
y dentro de HTML.

El proceso de creación y envío de un mensaje de correo electrónico

Para crear y enviar un mensaje de correo electrónico, siga estos pasos:

Crear un objeto MailMessage. MailMessage y otars clases relacionada al mail están en el namespace
[Link]. Si no ha especificado los beneficiarios en la MailMessage constructor, añadirlos al
objeto MailMessage.

Si usted necesita proporcionar múltiples vistas (como texto plano y HTML), crear objetos AlternateView
y añadirlos al objeto MailMessage.

Si es necesario, crear uno o más objetos Adjunto y añadirlos a la objeto MailMessage.

Crear un objeto smtpclient, y especificar el servidor SMTP. Si el servidor SMTP requiere para la
autenticación de clientes, añadir credenciales a la objeto smtpclient.

Pase su objeto MailMessage al método [Link]. Si lo prefiere, puede utilizar SmtpClient.

SendAsync para enviar el mensaje asincrónicamente.

Cómo crear una Objeto MailMessage

El objeto MailMessage tiene cuatro diferentes constructores que te permiten crear un espacio en
blanco MailMessage; especificar tanto el remitente y el destinatario, o bien especificar el remitente,
destinatario, asunto, y el cuerpo del mensaje. Si está creando un mensaje sencillo con un único
destinatario, que puede hacer la mayor parte del trabajo en la MailMessage constructor:

Imports [Link]
Module Module1
Sub main()
Dim m As MailMessage = New MailMessage _
(“[Link]@[Link]”, _
“yuripando@[Link]”, _
“Informe de Ingresos Trimestrales.”, _
“Vease documento de Informacion Adjunto”)
End Sub
End Module
274 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Si necesita especificar varios destinatarios, utiliza el constructor en blanco MailMessage . A

continuación, añadir los objetos MailAddress para la propiedad [Link] (que es de tipo
MailAddressCollection), y especificar [Link], [Link], y [Link]:

Dim m As MailMessage = New MailMessage()

[Link] = New MailAddress(“[Link]@[Link]”, “Cristian Sanchez”)
[Link](New MailAddress(“jpajuelo@[Link]”, “Javier Pajuelo”))
[Link](New MailAddress(“lHuachez@[Link]”, “Lily Huachez”))
[Link](New MailAddress(“fatima@[Link]”, “Fatima Sanchez”))
[Link] = “Informe de Ingresos Trimestrales.”
[Link] = “Vease documento de Informacion Adjunto.”

Para adjuntar un archivo, añadirlo a la [Link]

AttachmentCollection llamando al método [Link]. La manera más simple de

añadir un archivo es especificar el nombre del archivo:

Sub main()
Dim m2 As MailMessage = New MailMessage()
[Link](New Attachment(“C:\[Link]”))
End Sub

Cómo crear HTML E-mails

Para crear un HTML mensaje de correo electrónico, el suministro de etiquetas HTML para el contenido
MailMessageBody y establecer el atributo [Link] en True, como el siguiente código
muestra demuestra:

Sub main()
Dim m As MailMessage = New MailMessage
[Link] = New MailAddress(“[Link]@[Link]”, “Cristian Sanchez”)
[Link](New MailAddress(“Fatima@[Link]”, “Fatima Sanchez”))
[Link] = “Generacion de HTML”

‘ Especificar el Cuerpo de Mensaje HTML

[Link] = “<html><body><h1>My Message</h1><br>Este es un Mensaje HTML.</
body></html>”
[Link] = True

‘ Enviar el Mensaje
Dim client As SmtpClient = New SmtpClient(“[Link]”)
[Link](m)
End Sub

[Link] está siempre en formato de texto. Puede definir [Link] al igual

que cualquier página web HTML. Sin embargo, la mayoría de e-mail los clientes hacen caso omiso
de la sección <head>, hacer caso omiso de cualquier lado del scripts del cliente, y no descargar
automáticamente las imágenes de sitios web.

Para incrustar imágenes en un mensaje HTML de manera que aparecen cuando el usuario hace clic en
el mensaje (sin necesidad de que el usuario pueda elegir explícitamente para descargar las imágenes),
utiliza el AlternateView y LinkedResource clases.
 Capítulo 9: Trabajando con Email y Clientes Inteligentes 275

En primer lugar, crear un mensaje HTML utilizando AlternateView y, a continuación, añadir imágenes
usando LinkedResource, como muestra el siguiente código de muestra:

Imports [Link]
Module Module2
Sub main()
‘ Crea un Mensaje del Cuerpo HTML
‘ Referencia de mensajes utilizando el contenido ID
Dim htmlBody As String = “<html><body><h1>Picture</h1><br>” + _
“<img src=””cid:Pic1””></body></html>”
Dim avHtml As AlternateView = [Link] _
(htmlBody, Nothing, [Link])
‘ Crea un Objeto LinkedResource para cada imagen
Dim pic1 As LinkedResource = New LinkedResource(“[Link]”, MediaTypeNames.
[Link])
[Link] = “Pic1”
[Link](pic1)
Dim textBody As String = “Esta Utilizando un Mne”
Dim avText As AlternateView = [Link] _
(textBody, Nothing, [Link])
Dim m As MailMessage = New MailMessage
[Link](avHtml)
[Link](avText)
‘ Direccion y Envio de Mensaje
[Link] = New MailAddress(“lance@[Link]”, “Lance Tucker”)
[Link](New MailAddress(“james@[Link]”, “James van Eaton”))
[Link] = “A picture using alternate views”
Dim client As SmtpClient = New SmtpClient(“[Link]”)

End Sub
End Module

CÓMO ENVIAR MENSAJE

Una vez que haya creado un mensaje, tendrá que enviarlo a través de un SMTP (Simple Message
Transfer Protocol) del servidor, lo que a su vez lo remitirá al destinatario. En el. NET Framework, la
clase smtpclient representa el servidor SMTP. La mayor parte del tiempo, el envío de un mensaje es
tan simple como este código de muestra (donde “[Link]” es el nombre del servidor SMTP
local):

Dim m As MailMessage = New MailMessage _

(“[Link]@[Link]”, _
“ypando@[Link]”, _
“ Informe de Ingresos Trimestrales.”, _
“ Vease documento de Informacion Adjunto.”)
Dim client As SmtpClient = New SmtpClient(“[Link]”)
[Link](m)
276 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ejercicio #

Propiedades de los Controles

Controles Propiedades Valor

Label Text Nombre:
Label Text Usuario:
Label Text Email:
Label Text Password:
Label Text Host:
Label Text Puerto:
Label Text E-Mail :
Label Text Asunto :
Label Text Adjunto:
Label Text Mensaje:
Button (name) Button1
Text Enviar
Button (name) Button2
Text Borrar Datos
Button (name) Button3
Text …
Textbox (name) txtNombre
 Capítulo 9: Trabajando con Email y Clientes Inteligentes 277

Textbox (name) txtUsuario

Textbox (name) txtEmail
Textbox (name) txtPassword
Textbox (name) txtHost
Textbox (name) txtPuerto
Textbox (name) txtEmailDes
Textbox (name) txtAsunto
Textbox (name) txtAdjunto
Textbox (name) txtMensaje
Autosize False
Multiline True
Checkbox (name) Checkbox1

Código del formulario:

Las clases que se necesitan para poder trabajar

Imports System
Imports [Link]
Imports [Link]
Imports [Link]
Imports [Link]
Imports [Link]

Ahora escribimos el script para el envió del correo electrónico

Private Sub Button1_Click(ByVal sender As [Link], ByVal e As [Link])

Handles [Link]
Dim msg As [Link] = New [Link]()
[Link]([Link])
[Link] = New MailAddress([Link], [Link], [Link].
Encoding.UTF8)
If [Link] > 0 Then
[Link](New Attachment([Link]))
End If
[Link] = [Link]
[Link] = [Link].UTF8
[Link] = [Link]
[Link] = [Link].UTF8
[Link] = False
‘Aquí es donde se hace lo especial
Dim client As New SmtpClient()
[Link] = New [Link]([Link],
[Link])
[Link] = [Link]
[Link] = [Link]
If [Link] = True Then
[Link] = True ‘Esto es para que vaya a través de SSL que es
obligatorio con GMail
End If
If [Link] = False Then
[Link] = False
End If
278 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Try
[Link](msg)
MsgBox(“E-Mail enviado satisfacoriamente a: “ + [Link] +
vbNewLine + “Asunto: “ + [Link] + vbNewLine + “Datos Adjuntos: “ + Adjunto.
FileName)

[Link] = “”
[Link] = “”
[Link] = “”
[Link] = “”
[Link] = “”
[Link]()
Catch ex As [Link]
MsgBox([Link])
End Try
End Sub

Para poder limpiar todos los controles, que se encuentran

Private Sub Button2_Click(ByVal sender As [Link], ByVal e As [Link])

Handles [Link]
[Link] = “”
[Link] = “”
[Link] = “”
[Link] = “”
[Link] = “”
End Sub

Ahora se debe anexar al formulario un OpenFileDialog, al cual le vamos a dar el nombre de Adjunto,
luego se debe crear el siguiente evento

Public Sub LoadMyFile()

[Link] = “”
[Link] = “Todos los Archivos|*.*”
If ([Link]() = [Link]) _
And ([Link] > 0) Then
[Link] = [Link]
End If
End Sub

Private Sub Button3_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
LoadMyFile()
End Sub
 Capítulo 9: Trabajando con Email y Clientes Inteligentes 279

CREANDO UN MENSAJE DE EMAIL

Para enviar un eMail, crea un objeto MailMessage, especifica el remitente, el asunto, el cuerpo del
mensaje y los destinatarios, vistas alternativas y los archivos adjuntos si es que quieres enviarlos.

El objeto MailMessage incluye constructores para permitirte crear mensajes simples con una sola línea de
código. Mensajes más complejos y mensajes con múltiples destinatarios requerirán añadir más código.

Para adjuntar un archivo, crea una instancia del la clase Attachment y añádela a la colección
[Link].

Crear un mensaje HTML sin imágenes es tan simple como poner a True la propiedad MailMessage.
IsBodyHtml. Si necesitas incluir imágenes en el mensaje, crea un objeto AlternateView y otro
LinkedResource por cada imagen.

En los mensajes de eMail HTML se ignora la cabecera <head>.

ENVIANDO EMAIL
Para enviar un mensaje, crea una instancia de SmtpClient. Configuralo con el hostname del servidor
SMTP y llama al método [Link].

Si llamas al método [Link] sin definir el hostname del servidor, el CLR lanzará una
InvalidOperationException. Si el hostname esta definido pero no puede alcanzarse (por el motivo que
sea), el CLR lanzará una SmtpExeption con una WebException anidada. Si el servidor SMTP responde
diciendo que alguno de los destinatarios es inválido. El CLR lanzará una SmtpFailedRecipientException.
El resto de problemas que pudiesen surgir enviando un eMail resultarán en una SmtpException.

Para usar las credenciales de red por defecto, marca [Link] como True.
Para especificar un nombre de usuario y contraseña, crea una instancia de la clase [Link].
NetworkCredential y úsala para definir la propiedad [Link].

Para habilitar el cifrado SSL para la conexión SMTP, marca [Link] a True. No todos los
servidors SMTP soportan SSL.

Para enviar un mensaje de forma asíncrona, primero crea un método para responder al evento
[Link]. Después añade un manejador de eventos al [Link]
y llama al método [Link]. Puedes llamar a [Link] para cancelar
la trasmisión de un mensaje asíncrono antes de que sea completado.

Ejemplo #
Dim oMail As New [Link]
[Link] = [Link]
[Link] = “el email de quien envia”
[Link] = “el email que enviarás”
[Link] = “asunto”
[Link] = “El cuerpo del mensaje....”
[Link](“[Link] “,
“1”)
[Link](“[Link] “,
Usuario)
[Link](“[Link] “, Pwd)
Dim oSmpt As [Link]
[Link] = “ [Link]”
[Link](oMail)
280 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

CLIENTES INTELIGENTES
Clientes Ligeros (Aplicaciones Windows)
Hemos desarrollado utilizando algún lenguaje de programación para Windows (interfase) como Power
Builder, Visual Basic, tiene características buenas y malas, entre las buenas características:

Ventajas
• Experiencia de Usuario – los usuario estas aplicaciones tienen una gran experiencia de usuario
porque es muy amigable y sencilla.
• Alta productividad del Programador - Utilizar un paradigma de desarrollo a través de eventos, nos
permitió mucha facilidad del codificación.
• A deferencia de la aplicaciones de consola, nosotros todos los trabajamos a través de interfaces
visuales.
• Las interfaces responsivas – porque apenas dábamos clic en un botón nos daba una respuesta, eso
permitía gran interacción con el usuario.
• El mensaje los clientes ligeros tienen gran productivas de interfaces.

Desventajas
• Son pesadas, que distribuir el ejecutable entre los usuarios demoraba mucho, y ocupaba espacio
de memoria.
• Otros de los problemas eran las dll, teníamos que distribuir al cliente las dll del lenguaje de
programación, en algunos casos teníamos que registrar sobre Windows las dll, de ahí venia el
problema de los control de los versiones (compatibilidad).
• Otro de las cosas es que teníamos que desarrollar un instalador que pueda instalar todo lo que
necesita nuestra aplicación.

Aplicaciones Web
Ventajas
• Tienen un Alto alcance, porque mientras que tengas un navegador puede cualquier persona acceder
a este tipo de aplicación, sin importarle la plataforma, esto permitía que los usuario puedan ser
libres de la plataforma que maneja.
• Facilidad de Administración, porque residen solo un servidor Web, es mas fácil manejar los cambios
de la aplicación, donde simplemente los instalas en el servidor y todos desde cualquier lugar del
mundo pueden acceder

Desventaja
• Complejidad de Desarrollo, no es tan sencillo como desarrollar una aplicación Windows donde
trabajamos sobre los eventos de los objetos y además solo arrastramos controles , en el caso de
ASP, es escribir código, donde esta mezclado el código del lado del cliente y el código del lado del
servidor.
• Se reduce la experiencia de usuario, por se respetan los estándares HTML, navegadores, estar
basados en un protocolo. Es más difícil acceder a los recursos locales.
• Tenemos una dependencia de la Red, eso significa que si se cae el servidor toda la aplicación se
falla.
 Capítulo 9: Trabajando con Email y Clientes Inteligentes 281

Ahora la solución de negocios, que se viene trabajando desde del 2002, Son los Clientes inteligentes
(Smart Client), es como buscar la unión de las 2 mejores características de los clientes ligeros (Windows)
y clientes Pesados (Web), eso significa que saca lo mejor de cada uno, por ejemplo:
• Gran experiencia de Usuario, porque accede a recursos locales de la computadora.
• Pueden estar conectados a Un servidor o también pueden estar desconectados de alguna aplicación
• Tienen un Gran Alcance.
• Son fáciles de Administrar, fáciles de implementar.
• Gran Adaptabilidad a dispositivos y periféricos.
• Una Interfase muy responsiva.

En pocas las palabras es la unión de las formas de trabajar buscando lo mejor de cada uno.

Características de un cliente Inteligente

Veamos un ejemplo para desarrollar aplicaciones de Tipo Smart Client

Creemos una aplicación Windows, al cual le asignamos el nombre de SmartClientDemo.

Luego de esto cuando se creo el formulario Windows arrastramos un control que se llama
ToolStripContainer que se encuentra en la pestaña de Menus & Toolbars.
282 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Luego de arrastrarlo y soltarlo, damos clic en Dock Fill Form, para que pueda quedar en todo el formulario.

Ahora se pide arrastra un MenuStrip y luego dar clic en la opción que dice Insert Stándar Ítems, aparte
que como se encuentra dentro de un ToolStripContainer puede moverse para cualquier constado del
formulario.

De esta manera nos quedaría así el menú.

 Capítulo 9: Trabajando con Email y Clientes Inteligentes 283

Luego en la parte inferior del formulario arrastramos un StatusStrip, luego de esto vamos a dividir el
formulario en 2, para esto nos vamos a la pestaña Container, y seleccionamos splitContainer.

Luego seleccionamos la opción Horizontal Splitter Orientation para que la división quede en 2, en
forma horizontal.

Luego adicionamos el control de WebBrowser en la Parte Inferior de nuestro formulario, el cual nos
permitirá poder navegar en Internet.

Ahora lo que vamos hacer es escribir el siguiente código que me permita poder conectarme a Internet.

Private Sub Form1_Load(Byval sender as Object, Byval e as EventArgs) handles MyBase.

Load
[Link](“[Link]
End Sub
284 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Como resultado cuando lo ejecutemos tendremos el siguiente formulario, donde en la parte inferior
hace referencia a la página que hemos vinculado.

Perfecto hasta ahora todo es correcto y sencillo, continuemos con la construcción de Clientes
Inteligentes, vamos adicionarle una conexión a una base de datos, utilizando los wizard, pero ante
hablemos de lo que nos ofrece Visual Studio 2010 en los que acceso a datos:

Manejo de datos
• Nuevos Controles que soportan vinculaciones a datos, pueden mostrar rápidamente la información
de la Base de datos.
• Diseñador de datasets (Múltiples Tablas en un Objeto Local) tipiados basados en esquemas, para
poder validar las estructuras de nuestra base de datos contra los objetos creados.
• Tipos parciales para mantenimiento personalizado de código auto generado.

Server Explorer, es una herramienta que nos permite conectarme a nuestra base de datos, además de
poder crear tablas, procedimientos almacenados, etc.

Manipulación de datos Integrada

• Ahora continuemos con el ejemplo vamos adicionarla a este Cliente Inteligente, que pueda trabajar
con una base de datos.
• Para esto utilizaremos el Server Explorer, para esto trabajaremos con una base de datos
AdventureWorks de Sql Server [Link] nos vamos al menú Data, y buscamos la opción Show
Data Source.
 Capítulo 9: Trabajando con Email y Clientes Inteligentes 285

Ahora crearemos un nuevo origen de datos

Ahora nosotros elegimos un modelo de Base de datos

Nosotros podemos elegir cualquiera de estas opciones para crear un origen de dato, elegiremos la
Opción que dice Database.
286 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Luego de presionar siguiente, nos dirá cual será la conexión que nosotros elegiremos

En caso de que no exista conexión se podrá crear una nueva (lo que también se podría hacer por el
Server Explorer), en caso que se desea una nueva clic en el botón new connection
 Capítulo 9: Trabajando con Email y Clientes Inteligentes 287

En algunos casos esta ventana aparecerá indicando que puedes elegir cual será el origen de dato. Luego
de eso podrías generar la nueva conexión a la base de datos, tal como se ve en el ejemplo siguiente

Ahora luego de dar clic en OK regresaras a la ventana de conexión, luego de eso dar clic en next, y nos
mostrara la pantalla para poner el nombre que a va a tener la cadena de conexión, luego de eso clic
en next
288 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ahora elegimos de la base de datos que hemos creado la conexión la tabla con la cual deseamos
trabajar, en este caso utilizaremos contact(person)

Luego presionemos el finísh, para acabar la creación de la conexión, de tal manera que ahora
necesitamos arrastrar de la ventana del data Source, el nombre de la tabla y generaremos un
mantenimiento completo.

ClickOnce Deployment
Las aplicaciones son publicadas sobre un servidor Web, y el cliente a través de http puede solicitar la
aplicación a través de una pagina especifica que visual Studio 2010 genera, se la da el hipervínculo el
cliente puede descargar e instalarse localmente, y así hasta se puede verificar que si existe una nueva
versión.

Tiene las siguientes características:

• Tecnología de implantación de Clientes Inteligentes
• Provee una implementación Web sencilla
– Amigable para el usuario final
• Provee flexibilidad de implementación Web
– Amigable para el administrador encargado de publicar
• Otros Aspectos
– Las aplicaciones están aisladas de los usuarios
– Pueden ejecutarse con permisos locales limitados
 Capítulo 9: Trabajando con Email y Clientes Inteligentes 289

Ahora empezamos a crear un instalable para eso vamos a las propiedades de la aplicación, y
seleccionamos la pestaña publish.

En la parte inferior podemos controlar el tipo de version con la cual nosotros contamos, esto se va
actualizar cada vez que publiquemos.

Ahí encontramos un servidor(servidor Web) por defecto el cual lo podemos modificar para ubicarlo en
el servidor que se requiere, además crea un directorio virtual donde se va a buscar la aplicación, y no
solo con un servidor sino también en carpetas y otros.
290 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ahora continuamos podemos ejecutarlo de la siguiente manera.

Nosotros contamos con 4 botones, que nos permiten personalizar las opciones con los cuentas nuestro
Instalador

Archivo de Aplicacion
Ahora podemos especificar quienes son los archivos con los cuales nosotros vamos a contar, para esto
damos clic en el botón Archivo de Aplicacion.
 Capítulo 9: Trabajando con Email y Clientes Inteligentes 291

Requisitos Previos
Tambien podemos definirle los requisitos previos que necesita para que la aplicacion se pueda instalar
correctamente (botón requisitos previos):

Actualizaciones
Tambien podemos especificar las actualizaciones que puede tener la aplicacion (botón de
actualizaciones).
292 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Opciones
En el boton Opciones, también se puede definir los datos de la aplicacion como autor, empresa, etc.

Esto nos genera un wizard para la creación de una publicación

 Capítulo 9: Trabajando con Email y Clientes Inteligentes 293

Ahora hay una parte en la que podemos decidir si nuestra instalable va a trabajar en línea o no, se
debería escoger para que trabaje en línea (esto quiere decir que siempre tiene que ir al servidor) y no
línea(esto lo instala en el computador).

Luego de esto se pone finísh eso te permite generar la página virtual para que cualquier persona pueda
acceder simplemente accediendo a la página que se ha creado.
294 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Y simplemente lo que tenería que hacer es dar clic en el botón instalar y nos muestra esta ventana para
poder empezar a instalar.

Y eso te permite crear la aplicación instalada.

Podemos ver que ahora se encuentra instalada en nuestra maquina

De esta forma nosotros podemos generar las instalaciones de una manera rápida, pero pensemos que
de la versión 1 a la versión 2, que fue la ultima en instalarse hemos recurrido en un error y se desea
regresar a la versión anterior, este tipo instalación lo permite, nos vamos hasta Configuración – Panel
de control
 Capítulo 9: Trabajando con Email y Clientes Inteligentes 295

Cuando quieras desístanlar te la posibilidad de que puedas restaurar la versión anterior que instalastes
o borrar toda la aplicación. Es una ventaja porque permite al usuario poder seguir trabajando sin la
necesidad de esperar una nueva version.
 CAPÍTULO

10
Aprendiendo todo
sobre [Link] 4.0
 CAPÍTULO

10 Aprendiendo todo
sobre [Link] 4.0
El [Link] es un conjunto de componentes del software que pueden ser usados por los programadores
para acceder a datos y a servicios de datos. Es una parte de la biblioteca de clases base que están
incluidas en el Microsoft .NET Framework. Es comúnmente usado por los programadores para acceder
y para modificar los datos almacenados en un Sistema Gestor de Bases de Datos Relacionales, aunque
también puede ser usado para acceder a datos en fuentes no relacionales. [Link] es a veces
considerado como una evolución de la tecnología ActiveX Data Objects (ADO), pero fue cambiado tan
extensivamente que puede ser concebido como un producto enteramente nuevo.

ARQUITECTURA
[Link] consiste en dos partes primarias:

Data provider
Estas clases proporcionan el acceso a una fuente de datos, como Microsoft SQL Server y Oracle. Cada
fuente de datos tiene su propio conjunto de objetos del proveedor, pero cada uno tiene un conjunto
común de clases de utilidad:
• Connection: Proporciona una conexión usada para comunicarse con la fuente de datos. También
actúa como Abstract Factory para los objetos command.
• Command: Usado para realizar alguna acción en la fuente de datos, como lectura, actualización, o
borrado de datos relacionales.
• Parameter: Describe un simple parámetro para un command. Un ejemplo común es un parámetro
para un procedimiento almacenado.
• DataAdapter: Un puente usado para transferir datos entre una fuente de datos y un objeto DataSet
(ver abajo).
• DataReader: Una clase usada para procesar eficientemente una lista grande de resultados un
registro a la vez.

DataSets
Los objetos DataSets, un grupo de clases que describen una simple base de datos relacional en
memoria. Las clases forman una jerarquía de contención:
• Un objeto DataSet representa un esquema (o una base de datos entera o un subconjunto de una).
Puede contener las tablas y las relaciones entre esas tablas.
• Un objeto DataTable representa una sola tabla en la base de datos. Tiene un nombre, filas, y
columnas.
300 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

• Un objeto DataView “se sienta sobre” un DataTable y ordena los datos (como una cláusula “order
by” de SQL) y, si se activa un filtro, filtra los registros (como una cláusula “where” del SQL). Para
facilitar estas operaciones se usa un índice en memoria. Todas las DataTables tienen un filtro
por defecto, mientras que pueden ser definidos cualquier número de DataViews adicionales,
reduciendo la interacción con la base de datos subyacente y mejorando así el desempeño.
• Un DataColumn representa una columna de la tabla, incluyendo su nombre y tipo.
• Un objeto DataRow representa una sola fila en la tabla, y permite leer y actualizar los valores en
esa fila, así como la recuperación de cualquier fila que esté relacionada con ella a través de una
relación de clave primaria - clave extranjera.
• Un DataRowView representa una sola fila de un DataView, la diferencia entre un DataRow y el
DataRowView es importante cuando se está interactuando sobre un resultset.
• Un DataRelation es una relación entre las tablas, tales como una relación de clave primaria - clave
ajena. Esto es útil para permitir la funcionalidad del DataRow de recuperar filas relacionadas.
• Un Constraint describe una propiedad de la base de datos que se debe cumplir, como que los
valores en una columna de clave primaria deben ser únicos. A medida que los datos son modificados
cualquier violación que se presente causará excepciones.

Un DataSet es llenado desde una base de datos por un DataAdapter cuyas propiedades Connection y
Command que han sido iniciados. Sin embargo, un DataSet puede guardar su contenido a XML (opcionalmente
con un esquema XSD), o llenarse a sí mismo desde un XML, haciendo esto excepcionalmente útil para los
servicios Web, computación distribuida, y aplicaciones ocasionalmente conectadas.

Entity Framework
El [Link] Entity Framework es un conjunto de APIs de acceso a datos para el Microsoft .NET
Framework, apuntando a la versión de [Link] que se incluye apartir del .NET Framework 3.5.. Una
entidad del Entity Framework es un objeto que tiene una clave representando la clave primaria de
una entidad lógica de datastore. Un modelo conceptual Entity Data Model (modelo Entidad-Relación)
es mapeado a un modelo de esquema de datastore. Usando el Entity Data Model, el Framework
permite que los datos sean tratados como entidades independientemente de sus representaciones
del datastore subyacente.

El Entity SQL es un lenguaje similar al SQL para consultar el Entity Data Model (en vez del datastore
subyacente). Similarmente, las extensiones del Linq, Linq-to-Entities, proporcionan consultas tipeadas
en el Entity Data Model. Las consultas Entity SQL y Linq-to-Entities son convertidas internamente
en un Canonical Query Tree que entonces es convertido en una consulta comprensible al datastore
subyacente (ej. en SQL en el caso de una base de datos relacional). Las entidades pueden utilizar sus
relaciones, y sus cambios enviados de regreso al datastore.

El modelo de objetos [Link] provee una estructura de acceso a distintos orígenes de datos. Tiene 2
componentes principales: El Dataset y el proveedor de Datos .NET
 Capítulo 10: Aprendiendo todo sobre [Link] 4.0 301

Una estructura más profunda de la Arquitectura de [Link], donde podemos observar mas al detalle
los objetos que lo componen

El proveedor de datos .NET Framework

El proveedor de datos .NET provee del enlace entre el Origen de Datos y el DataSet. Un proveedor de
datos de .NET Framework sirve para conectarse a una base de datos, ejecutar comandos y recuperar
resultados. Esos resultados se procesan directamente o se colocan en un DataSet de [Link] con
el fin de exponerlos al usuario para un propósito específico, junto con datos de varios orígenes, o de
utilizarlos de forma remota entre niveles.

El diseño del proveedor de datos de .NET Framework hace que sea ligero, de manera que cree un
nivel mínimo entre el origen de datos y su código, con lo que aumenta el rendimiento sin sacrificar la
funcionalidad.

Proveedor de datos de .NET Framework Descripción

Proveedor de datos de .NET para SQL Server Para Microsoft® SQL Server™ versión 7.0 o
posteriores.
Proveedor de datos de .NET para OLE DB Para orígenes de datos que se exponen
mediante OLE DB.
Proveedor de datos de .NET para Oracle Para orígenes de datos de Oracle. El
proveedor de datos de .NET Framework
para Oracle es compatible con la versión
8.1.7 y posteriores del software del cliente
de Oracle.
Proveedor de datos de .NET para ODBC Para orígenes de datos que se exponen
mediante ODBC.
302 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Objetos provistos por distintos proveedores de datos .NET

Los objetos Connection, Command, DataReader y DataAdapter son los elementos fundamentales del
modelo de proveedor de datos de .NET Framework. En la tabla siguiente se describen estos objetos.

Objeto Descripción Objeto SQL Server Objeto OleDB

Establece una conexión a un
Connection SqlConnection OleDBConnection
origen de datos determinado.
Ejecuta un comando en un
Command SqlCommand OleDBCommand
origen de datos.
Lee una secuencia de datos de
DataReader sólo avance y sólo lectura desde SqlDataReader OleDBDataReader
un origen de datos.
Llena un DataSet y realiza las
DataAdapter actualizaciones necesarias en el SqlDataAdapter OleDBDataAdapter
origen de datos.

Estudiando el Objeto XXXConnection

Las primeras iniciales hacen referencia al nombre del proveedor, como la mayoria de los ejemplo lo
realizaremos con el manejador de Datos SQL Server llevara el prefijo SQL.

Este objeto representa una conexión abierta con una base de datos de SQL Server, el objeto
SqlConnection representa además una única sesión con un origen de datos. SqlConnection se utiliza
junto con SqlDataAdapter y SqlCommand para aumentar el rendimiento de la conexión a una base de
datos de Microsoft SQL Server

ConnectionString - Obtiene o establece la cadena utilizada para abrir una base de datos de SQL Server.

Database - Obtiene el nombre de la base de datos actual o de la que se va a utilizar una vez que se
abre la conexión.

DataSource - Obtiene el nombre de la instancia de SQL Server con la que se va a establecer la conexión.

ChangeDatabase - Cambia la base de datos actual de una conexión SqlConnection abierta.

 Capítulo 10: Aprendiendo todo sobre [Link] 4.0 303

Open - Abre una conexión de base de datos con los valores de propiedad que especifica el
ConnectionString o la cadena de conexión cargada.

Close - Cierra la conexión con la base de datos

CreateCommand - Crea y devuelve un objeto SqlCommand asociado a la conexión SqlConnection.

Ejemplo de Conexión con el Objeto SqlConnection

1 – Para este ejemplo Utilizaremos la Base de Datos de SQL Server, Este proyecto debe ser basado en
Aplicación Windows, con el nombre BDNegocio_ADO.

El diseño del formulario será el siguiente:

Para esto crearemos un formulario, en el espacio de codigo necesitamos cargar dos espacios de
nombres necesarios cada vez que utilicen objetos de base de datos, que son [Link] y System.
[Link].
304 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Se debe crear las variables que representara la cadena de conexión y el objeto conexión, en un
ambito general del formulario o si deseas lo puedes crear en un Modulo, para que lo puedas utilzar en
diferentes formularios:

Imports [Link]
Module ModConexion
Dim strcon As String = “Initial Catalog = AdventureWorks;Data Source= Server;
integrated security=True;”
Public cn As New SqlConnection(strcon)
End Module

Crear el siguiente método en el formulario:

Private Sub MostrarInformacion()

[Link] = “Conexion Satisfactoria”
[Link] = [Link]
[Link] = [Link]
[Link] = [Link]
End Sub

En el botón Probar Conexion colocamos lo siguiente:

Private Sub btnProbarCad_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Try
[Link]()
MostrarInformacion()
[Link]()
Catch ex As [Link]
‘Control de errores
[Link] = [Link]
Catch ex As Exception
[Link] = [Link]
End Try
End Sub

En el Botón Cambiar colocamos lo siguiente:

Private Sub btnCambiarBD_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Try
[Link]()
[Link](“master”)
MostrarInformacion()
[Link]()
Catch ex As [Link]
‘Control de errores
[Link] = [Link]
Catch ex As Exception
[Link] = [Link]
End Try
End Sub
 Capítulo 10: Aprendiendo todo sobre [Link] 4.0 305

Nos Mostrara como resultado lo siguiente:

Trabajando con el Método Desconectado y Conectado

Cuando trabajamos con una conexión utilizando el SqlConnection , es igual para los Metodos Conectados
y Desconectado(mas adelante tocaremos mas a fondo cada uno de ellos), ahora realizaremos un
ejemplo con cada uno de ellos de la manera mas sencilla, para que vean el funcionamiento del
SqlConnection.

Ejemplo del Metodo DesConectado – Utilizando el SqlConnection

Para esto vamos a crear un formulario bien simple el cual debe tener un dataGridView, para cargar la
data y un boton para ejecutar la conexión , el formulario debe quedar de la siguiente manera:

Ahora desarrollaremos el siguiente codigo:

Imports [Link]
Imports [Link]
Public Class frmMetodoConec
Dim xcon As New SqlConnection(“Data Source =.;initial Catalog=AdventureWorks;u
id=sa;pwd=dba;”)
Dim oDa As New SqlDataAdapter(“select * from [Link]”, xcon)
Dim oDs As New DataSet
Private Sub btnCargar_Click(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
[Link](oDs, “Empleado”)
[Link] = [Link](“Empleado”)
End Sub
End Class
306 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Dando como resultado la siguiente información que se muestra:

Ejemplo del Metodo Conectado – Utilizando el SqlConnection

Para esto vamos a crear un formulario bien simple el cual debe tener un Listbox, para cargar la data
y un boton para ejecutar la conexión y carga de Datos, el formulario debe quedar de la siguiente
manera:
 Capítulo 10: Aprendiendo todo sobre [Link] 4.0 307

Ahora escribirenmos el siguiente codigo y nos daremos cuenta que la conexión es igual al del metodo
conectado.

Imports [Link]
Imports [Link]
Public Class frmMetodoDesCon
Dim xcon As New SqlConnection(“Data Source =.;initial Catalog=AdventureWorks;u
id=sa;pwd=dba;”)
Dim sql As New SqlCommand(“select * from [Link]”, xcon)
Dim dr As SqlDataReader
Private Sub btnCargar_Click(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
[Link]()
dr = [Link]
While [Link]
[Link](CStr(dr.GetInt32(0)) + “ - “ + [Link](5))
End While
[Link]()
End Sub
End Class

Dando como resultado la informacion que a continuacion se muestra:

En este caso a diferencia del metodo desconectado, la variable de tipo conexión siempre tiene que
activarse antes de utilizarse([Link]) y luego cerrar la conexión([Link])
308 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ejemplo con SqlConnectionStringBuilder

Otra forma de poder conectarme a la Base de Datos es atraves del Objeto SqlConnectionStringBuilder,
Es una de las nuevas clases apartir del .NET Framework 2.0 , que nos sirve para construir nuestras
cadenas de conexión para ser utilizadas con los objetos basados en SqlConnection.

El uso es simple y tiene dos sentidos, el primero es que se puede construir a partir de una cadena de
conexión con lo cual se descompone en los elementos de la cadena como Servidor, base de datos,
Id de Usuario, contraseña, si es autenticación integrada, etc. El segundo sentido es que a partir de la
asignación las propiedades del objeto se obtiene una cadena de conexión válida para iniciar sesión en
un servidor SQL Server.

Realicemos un ejemplo corto de cómo podemos utilizar el SqlConnectionStringBuilder, para este

utilizaremos la segunda forma, ya que deseamos construir una cadena de conexión válida en base
a los datos que tenemos de nuestro servidor, de esta manera, podremos intuir si la cadena utiliza
autenticación integrada o no basándonos en el criterio del usuario, así es, si no se define un UserId,
podemos inferir de manera atrevida que se está intentando iniciar la sesión con autenticación integrada,
ya que si pasamos el valor del usuario en blanco será seguro que el servidor rechace el inicio de sesión
por no contar con inicios de sesión en blanco. Bien, veamos esto en el siguiente ejemplo:

[Link]
Dim Cn As SqlConnectionStringBuilder = New SqlConnectionStringBuilder()
[Link] = Server
[Link] = Database
[Link] = UserId
[Link] = PassW
[Link] = ([Link]() = “”)

C#
SqlConnectionStringBuilder Cn = new SqlConnectionStringBuilder();
[Link] = Server;
[Link] = DataBase;
[Link] = UserId;
[Link] = PassW;
[Link] = [Link]() == “”;

Ahora Desarrollemos un ejemplo completo con SqlStringBuilder

Desarrollemos el Siguiente Diseño de Formulario

 Capítulo 10: Aprendiendo todo sobre [Link] 4.0 309

Todo el código lo desarrollaremos en el Boton Copiar BD

Imports [Link]
Imports [Link]
Public Class frmBackup
Private Sub Button1_Click(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
Dim sBackup As String = “BACKUP DATABASE “ & [Link] & _
“ TO DISK = N’” & [Link] & _
“’ WITH NOFORMAT, NOINIT, NAME =N’” & [Link] & _
“-Full Database Backup’,SKIP, STATS = 10”

Dim cs As New SqlConnectionStringBuilder

[Link] = [Link]
[Link] = [Link]
[Link] = True

Using xcn As New SqlConnection([Link])

Try
[Link]()
Dim cmdBackUp As New SqlCommand(sBackup, xcn)
[Link]()
MsgBox(“Se ha creado un BackUp de La base de datos”)
[Link]()
Catch ex As Exception
MsgBox([Link],”Error al copiar la base de datos”)
End Try
End Using
End Sub
End Class

Y cuando se ejecute nos mostrara el siguiente mensaje

Estudiando el Objeto XXXDataAdapter

Las primeras iniciales hacen referencia al nombre del proveedor, como la mayoria de los ejemplo lo
realizaremos con el manejador de Datos SQL Server llevara el prefijo SQL.

Representa un conjunto de comandos de datos y una conexión de base de datos que se utilizan para
rellenar un DataSet y actualizar una base de datos de SQL Server. Esta clase no se puede heredar.

SqlDataAdapter, se utiliza como un puente entre DataSet y SQL Server para recuperar y guardar datos.
SqlDataAdapter proporciona este puente mediante la asignación de Fill, que cambia los datos en
DataSet para que coincidan con los datos del origen de datos; y Update, que cambia los datos en el
origen de datos para que coincidan con los datos en DataSet utilizando las instrucciones de Transact-
SQL en el origen de datos adecuado.
310 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

DeleteCommand - Compatible con .NET Compact Framework, Obtiene o establece un procedimiento

almacenado o una instrucción de Transact-SQL para eliminar registros de un conjunto de datos.

InsertCommand - Compatible con .NET Compact Framework, Obtiene o establece un procedimiento

almacenado o una instrucción de Transact-SQL para insertar nuevos registros en el origen de datos.

SelectCommand - Compatible con .NET Compact Framework, Obtiene o establece un procedimiento

almacenado o una instrucción de Transact-SQL para seleccionar registros en el origen de datos.

UpdateCommand - Compatible con .NET Compact Framework, Obtiene o establece un procedimiento

almacenado o una instrucción de Transact-SQL para actualizar los registros del origen de datos.

Fill (se hereda de DbDataAdapter) - Compatible con .NET Compact Framework, Sobrecargado.
Reemplazado. Agrega filas a DataSet o las actualiza para que coincidan con las filas del origen de datos.

FillSchema (se hereda de DbDataAdapter) - Compatible con .NET Compact Framework, Sobrecargado.
Reemplazado. Agrega DataTable a DataSet y configura el esquema para hacerlo coincidir con el del
origen de datos.

Update (se hereda de DbDataAdapter) - Compatible con .NET Compact Framework, Sobrecargado.
Llama a las instrucciones INSERT, UPDATE o DELETE respectivas para cada fila insertada, actualizada o
eliminada en DataSet.

Ejemplo Utilizando SqlDataAdapter

Empecemos diseñando en el siguiente formulario con el nombre frmDataAdapter.
 Capítulo 10: Aprendiendo todo sobre [Link] 4.0 311

Para poder realizar este ejemplo necesitaremos instalar la base de datos Northwind en el SqlServer
2008, luego de esto empezaremos con la codificacion, Crearemo la siguiente variable en el formulario
en un ambito global para ser accedido:

Dim dsTablas As New DataSet

En el load del formulario colocaremos lo siguiente:

Private Sub frmAdapter1_Load(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
‘Carga de la Informacion
Try
‘1ra forma
Dim scon As String = “Select * from employees”
Dim AdpEmpleado As New SqlDataAdapter(scon, cn)
[Link](dsTablas) ‘Donde lo ponemos nombre a la tabla a insertar
‘2da forma
scon = “Select * from products”
Dim AdpProductos As New SqlDataAdapter(scon, cn)
[Link](dsTablas, “Productos”)
‘3ra forma
[Link]()
scon = “Select * from Customers”
Dim AdpCliente As New SqlDataAdapter(scon, cn)
[Link](dsTablas, “Clientes”)
[Link]()
Catch ex As Exception
[Link]([Link], “Error de Carga”)
End Try
End Sub

En los botones de Mostrar Empleados, Productos, Clientes colocar lo siguiente:

Private Sub btnMostarEmp_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
[Link] = [Link](0)
End Sub

Private Sub btnMostarCli_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
[Link] = [Link](“clientes”)
End Sub

Private Sub btnMostrarProd_Click(ByVal sender As [Link], ByVal e As

[Link]) Handles [Link]
[Link] = [Link](“Productos”)
End Sub
312 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Obteniendo como resultado, la visualización de la información, a través de los dataGridView tal como
se muestra en la siguiente imagen.

El Objeto DataSet
El objeto DataSet es esencial para admitir escenarios de datos distribuidos de [Link] sin mantener
una conexión. El DataSet es una representación residente en memoria de datos que proporciona un
modelo de programación relacional coherente independientemente del origen de datos. Se puede
utilizar con múltiples y distintos orígenes de datos, con datos XML o para administrar datos locales de
la aplicación. El DataSet representa un conjunto completo de datos entre los que se incluyen tablas
relacionadas, restricciones y relaciones entre las tablas.

Modelo del Objeto DataSet

 Capítulo 10: Aprendiendo todo sobre [Link] 4.0 313

Como DataSet es una pequeña base de datos relacional mantenida en memoria en el cliente, dispone
de la capacidad de crear múltiples tablas, rellenarlas con datos que procedan de diferentes fuentes,
imponer relaciones entre pares de tablas, etc.

IMPORTANTE
DataSet aunque posee excelentes características, no siempre es la mejor respuesta a todos los
problemas de programación de bases de datos. DataSet es bueno para que las aplicaciones Cliente/
Servidor tradicionales, como una aplicación Windows Forms que consulte una base de datos en un
servidor de red, pero casi siempre será una mala elección en aplicaciones [Link] y, de forma más
general, en todos los entornos que no guarden estado.

Puede llenar un DataSet de varias maneras:

• Invocar el método Fill de un adaptador de datos (DataAdapter). Esto provoca que el adaptador
ejecute una instrucción SQL o procedimiento almacenado y llene los resultados en una tabla en el
conjunto de datos. Si el DataSet contiene varias tablas, probablemente tiene diferentes adaptadores
de datos para cada tabla y debe, por tanto, invocar el método Fill del cada adaptador por separado.

Objeto SqlCommandBuilder
Genera automáticamente comandos de tabla única que se utilizan para conciliar los cambios realizados
en un objeto DataSet con la base de datos de SQL Server asociada. Esta clase no se puede heredar. Por
si solo el SqlDataAdapter no genera automáticamente las instrucciones de modificación requeridas
para realizar los cambios de un DataSet con la instancia asociada de SQL Server, pero se puede crear
un objeto SqlCommandBuilder que genera automáticamente instrucciones de modificación para las
actualizaciones de una sola tabla.

El objeto SqlCommandBuilder se asocia como un ente que reacciona a eventos de RowUpdating

siempre que se establezca la propiedad en el SqlDataAdapter.
314 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

La asociación entre el SqlDataAdapter y SqlCommandBuilder sólo se pueden asociar un objeto

SqlDataAdapter y un objeto SqlCommandBuilder simultáneamente. SqlCommandBuilder en síntesis lo
que hace este objeto es implementar al DataAdapter con comandos para que ejecuten las tareas de:

Insert
Update
Delete

Como trabajar con el Objeto SqlCommandBuilder y el SqlDataAdapter:

Primero creamos el SqlDataAdapter instanciado con la consulta y conexión establecida.
Objeto As New SqlDataAdapter (Consulta, Conexión)

Luego, definir un SqlCommandBuilder para agregarle el parámetro que necesita indicándole el

SqlDataAdapter que tenemos que implementar
SqlCommandBuilder (SqlDataAdapter)

Para realizar los cambios del DataSet en la base de datos se debe ejecutar el método Update desde el
DataAdapter
[Link] (DataSet)

Y antes de realizar lo anterior tenemos que saber si es que el DataSet ha sido modificado, para esto
podemos preguntar en el DataSet con HasChanges que devuelve false o true si es que ha cambiado el
DataSet.:
[Link]

Existen 2 formas de poder trabajar el sqlCommandBuilder , trabajando con el SqlDataAdapter:

Forma No Administrada, en donde va a realizar todos procesos de afectación a la base de datos

(insertar, actualizar y eliminar).

Forma Administrada, es cuando podemos determinar qué proceso de afectación queremos hacer
sobre la base de datos.

Para entender mejor esto realizaremos 2 ejemplos (uno de cada forma)

Método Forma No Administrada

Creamos un formulario con el nombre frmMetodoNoAdm, el cual tendrá el siguiente diseño:
 Capítulo 10: Aprendiendo todo sobre [Link] 4.0 315

Necesitamos las siguientes variables globales:

Dim xcn As New SqlConnection(“server=.;Database=BDSistemas;Integrated Security=True;”)

Dim sql As String = “Select * from clientes”
Dim Adp As New SqlDataAdapter(sql, xcn)
Dim ds As New DataSet

En el load del formulario colocamos lo siguiente:

Private Sub frmMetodoNoAdm_Load(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
[Link](ds, “Clientes”)
Dim xBuilder As New SqlCommandBuilder(Adp)
[Link] = [Link](“Clientes”)
End Sub

En el botón Actualizar agregamos:

Private Sub btnActualizar_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
If [Link] Then
[Link](ds, “Clientes”)
[Link](“Cambios Efectuados Ok!!!!”, “Mantenimiento de Clientes”)
End If
End Sub

Al ejecutar el formulario, debemos agregar 4 registros en el DataGridView, modificar 2 de ellos y eliminar

uno de ellos, al realizar esto, las modificaciones están ocurriendo en el DataSet, al momento de darle
clic al botón modificar estamos haciendo que los cambios efectuados en el DataSet lo modificamos en
la base de datos.

Método Forma Administrada

La forma más correcta de trabajar en forma desconectada es que nosotros mismos controlemos
nuestros cambios a la base de datos, para esto el DataAdapter se le puede configurar, observemos
primero el siguiente ejemplo.

El SqlDataAdapter para administrar las modificaciones a la base de datos cuenta con comandos para
definir, primero debemos configurar este comando e indicarle que tipo de modificación debe realizar;
luego se le asigna al SqlDataAdapter con el comando especifico según la acción del comando.
316 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

La configuración del SqlCommand, varia al del anterior en este tenemos que indicarle el tipo de dato y
además el nombre del campo que se hace referencia.

[Link] - Obtiene o establece un procedimiento almacenado o una

instrucción de Transact-SQL para seleccionar registros en el origen de datos.

SqlCommand ([Procedimiento para la Inserción], [Conexión])

[Link] = SqlCommand

[Link] - Obtiene o establece un procedimiento almacenado o una

instrucción de Transact-SQL para insertar nuevos registros en el origen de datos.

SqlCommand ([Procedimiento para la Inserción], [Conexión])

[Link] = SqlCommand

[Link] - Obtiene o establece un procedimiento almacenado o una

instrucción de Transact-SQL para eliminar registros de un conjunto de datos.

SqlCommand ([Procedimiento para la Inserción], [Conexión])

[Link] = SqlCommand

[Link] - Obtiene o establece un procedimiento almacenado o una

instrucción de Transact-SQL para actualizar los registros del origen de datos.

SqlCommand ([Procedimiento para la Inserción], [Conexión])

[Link] = SqlCommand

Ejemplo Método Administrado

Crear un nuevo formulario con el nombre frmMetodoAdm y el siguiente diseño:

Debemos crear las siguientes variables:

Dim cnx As New SqlConnection(“server=.;Database=BDSistemas;Integrated

Security=True;”)
Dim adp As New SqlDataAdapter
Dim ds As New DataSet
Dim nombre, apellidos, direccion
Dim codigo, sueldo As Integer
 Capítulo 10: Aprendiendo todo sobre [Link] 4.0 317

En el load del formulario colocaremos lo siguiente:

Private Sub frmMetodoAdm_Load(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Try
[Link]()
‘Mostra Informacion
Dim xcmd As New SqlCommand(“ss_clientes”, cnx)
[Link] = [Link]
[Link] = xcmd
‘Eliminacion de la Informacion
xcmd = New SqlCommand(“sd_clientes”, cnx)
[Link] = [Link]
[Link](“@codigo”, [Link], 4, “codigo”)
[Link] = xcmd
‘Insertar registros
xcmd = New SqlCommand(“si_clientes”, cnx)
With xcmd
.CommandType = [Link]
.[Link](“@codigo”, [Link], 4, “codigo”)
.[Link](“@nombres”, [Link], 30, “nombres”)
.[Link](“@apellidos”, [Link], 30, “apellidos”)
.[Link](“@direccion”, [Link], 60, “direccion”)
.[Link](“@ingreso”, [Link], 4, “ingreso”)
End With
[Link] = xcmd
‘Actualizar registros
xcmd = New SqlCommand(“su_clientes”, cnx)
With xcmd
.CommandType = [Link]
.[Link](“@codigo”, [Link], 4, “codigo”)
.[Link](“@nombres”, [Link], 30, “nombres”)
.[Link](“@apellidos”, [Link], 30, “apellidos”)
.[Link](“@direccion”, [Link], 60, “direccion”)
.[Link](“@ingreso”, [Link], 4, “ingreso”)
End With
[Link] = xcmd
[Link](ds, “Clientes”)
[Link] = [Link](“Clientes”)
Catch ex As Exception
MsgBox([Link])
Finally
[Link]()
End Try
End Sub

Y en el botón modificar colocamos lo siguiente:

Private Sub btnActualizar_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Try
If [Link] Then
[Link](ds, “Clientes”)
[Link](“Cambios Efectuados Ok!!!!”, “Mantenimiento de
Clientes”)
End If
Catch ex As Exception
MsgBox([Link])
End Try
End Sub
318 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Al ejecutar este formulario, obtendremos lo siguiente:

Trabajando una Consulta utilizando Wizard en [Link]

Vamos a diseñar una consulta de 2 tablas (cabecera - detalle), para poder empezar el ejercicio vamos
a ir al cuadro de herramientas, nos ubicarnos en la pestaña de data, y damos clic en el botón derecho,
seleccionamos choose item y nos mostrará la siguiente ventana.

En dichas ventanas seleccionaremos los comandos SqlCommand, SqlConnection, SqlDataAdapter y

SqlDataSource. Los elementos seleccionados se agregaran en dicha pestaña, tal como se puede apreciar
 Capítulo 10: Aprendiendo todo sobre [Link] 4.0 319

Ahora vamos a arrastrar el objeto SqldataAdapter y lo soltamos en el formulario, Se empezara a cargar

el Wizard, lo primeros que hacemos es crear una conexión a la base de datos PUBS.

Creamos una nueva conexión a la base de datos, para eso damos clic en el botón new connection
320 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Al momento de crear una conexión se debe definir el nombre del servidor, el tipo de autentificación y
la selección de la base de datos. Adicionalmente se puede probar la conexión a la base datos a través
del botón Test Connection. Luego de daremos clic en el botón ok, quedara de la siguiente manera la
conexión.

Luego presionamos el boton Next, y debemos determinar que tipo de sentencia se va a manejar,
nosotros usaremos Use SQL Staments
 Capítulo 10: Aprendiendo todo sobre [Link] 4.0 321

Luego nosotros podemos ingresar la sentencia SQL con la cual deseamos generar el SqlDataAdapter,
como vemos en la siguiente pantalla:

Luego al dar clic nos mostrara la siguiente ventana donde nos dice que nostros con el Adapter podemos
hacer intrucciones tales como Select, Insert, Update y Delete
322 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Luego de Poner Finísh nos daremos cuenta que se ha creado un Sqlconnection y un SqlDataAdapter

Bueno, ahora vamos a trabajar con otro SqlDataAdapter, para eso vamos a arrastrar otro SqlDataAdapter
encima del formulario, y repetimos los pasos hasta la generación de la instrucción SQL.
 Capítulo 10: Aprendiendo todo sobre [Link] 4.0 323

En este ejemplo no vamos a escribir el código, sino vamos a dar clic en el Query Builder

Nos mostrar esta ventana donde nos aparecerá todas las tablas que pertenecen a esa conexión,
elegiremos la tabla correspondiente para el ejemplo que este caso seria TiTles

Nos mostrara un ambiente donde nosotros podemos elegir la tabla y los campos correspondientes,
adicionalmente podemos ver el resultado de la ejecución.
324 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Luego ponemos OK, y ponemos un Finís, nos damos cuenta que se adiciono otro SqlDataAdapter, pero
solo se mantuvo un solo SqlConnection (porque se trabaja con la misma conexión)

Desde el Menú Data, seleccione la opción Generate DataSet, complete de acuerdo a la siguiente
representación:

Dentro de la generación de DataSet, vamos a relacionar las 2 tablas que nosotros hemos definido como
en el SqlDataAdapter.
 Capítulo 10: Aprendiendo todo sobre [Link] 4.0 325

Luego de haber realizado esto en la parte inferior del formulario mostrará los siguientes controles

Luego en el Explorador podemos apreciar que se ha creado un objeto DataSet

Ahoramos damos doble clic sobre el control, nos mostrará la siguiente ventana, en la cual aparecera
las tablas generados en el SqlDataAdapter

Ahora vamos a relacionar las tablas, arrastramos el control Relation, sobre las tablas titles, y nos
mostrara la siguiente ventana:
326 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Después de dejar los datos tan igual como la gráfica dar clic en el botón OK. Quedando el DataSet de
esta manera:

Luego crearemos un formulario que consta de 2 objetos, Un ListBox y un dataGrid

 Capítulo 10: Aprendiendo todo sobre [Link] 4.0 327

Ahora modificamos las propiedades de los controles que hemos adicionado, de la siguiente manera:

Control Propiedades Valor

ListBox1 DataSource DsPublishersTitles1
DisplayMenber Publishers.pub_name
Dock Left
dataGridView1 DataSource DsPublishersTitles1
DataMenber [Link](relation)
Dock Fill

Ahora para poder Terminar codificamos lo siguiente en el evento Load

Private Sub Form3_Load(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
[Link]()
[Link](DsPublishersTitles1)
[Link](DsPublishersTitles1)
End Sub

El formulario cuando se ejecute se mostrara de la siguiente manera:

328 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

EJEMPLO DE SINCRONIZACIÓN DE [Link] 4.0 CON SQL SERVER 2008

En este ejemplo utilizamos una base de datos de SQL Server 2008, pero podemos desarrollarla en
cualquier otra base de datos, solo que tendrás que modificar la cadena de conexión y el tipo del
DataAdapter usado para acceder a los datos. Existe una tabla llamada Clientes.

Creación de Tabla
En la Base de datos que UD. Elija (Nosotros para el ejemplo hemos utilizado la base de datos Northwind),
crear la siguiente tabla:

Create table clientes(

id int identity(1,1) not null,
nombre varchar(30) null,
apellidos varchar(40) null,
domicilio varchar(40) null,
distrito varchar(40) null,
provincia varchar(40) null,
nif varchar(20) null,
Email varchar(60) null,
observaciones varchar(255) )

Luego de Crearla Insertar algunos registros, tal como muestra el ejemplo:

insert into clientes values(‘Fatima’,’Sanchez’,’Las begonias’,’Pueblo

Libre’,’Lima’,’’,’fsanez@[Link]’,’’)
insert into clientes values(‘Liliana’,’Huachez’,’Jr. Huarochiri’,’Miraflores’,’Lima
’,’’,’FYSH@[Link]’,’’)
insert into clientes values(‘Zolia’,’Flores’,’Las Jardenias’,’Surquillo’,’Lima’,’’
,’zpro@[Link]’,’’)
insert into clientes values(‘Silvia’,’Zuñiga’,’Segoviana’,’Lince’,’Lima’,’’,’silvi
ta@[Link]’,’’)
insert into clientes values(‘Jackie’,’Herrera’,’Perez’,’Surco’,’Lima’,’’,’Capullo@
[Link]’,’’)
insert into clientes values(‘Isabel’,’Sanchez’,’Alvares’,’Ate’,’Lima’,’’,’Titibel@
[Link]’,’’)
insert into clientes values(‘Lissethe’,’Davila’,’de las Casas’,’Comas’,’Lima’,’’,’
hdt_2454@[Link]’,’’)

Se recomienda ingresar por lo menos 15 registros de información para que se pueda ver el
ejemplo mucho mejor

Ahora vamos a empezar a construir el formulario que me a servir para el trabajo con Base de datos

Te explico lo que he hecho para que lo entiendas bien y puedas adaptarlo a tus necesidades.

Esa tabla tiene varios campos, pero en este ejemplo solo se usan dos: Nombre y Apellidos.
 Capítulo 10: Aprendiendo todo sobre [Link] 4.0 329

En el formulario de ejemplo uso estos controles

Una etiqueta, una caja de textos llamada txtApellidos, un ListBox para mostrar lo que se vaya
encontrando conforme escribes, esa lista se llama listaApellidos. También hay un control de tipo
DataGridView en el que se mostrarán los datos que hemos leído de la base de datos, ese control se
llama datosClientes.

Cuando se escribe algo en la caja de textos, se busca en la base de datos (en realidad en el contenido
del DataTable que hemos cargado al iniciar la aplicación), y se van mostrando los datos en la lista. Se
puede realizar el ejemplo con la letra S.

Empezamos a codificar para que el formulario pueda funcionar correctamente.

Aparte de los controles que te he comentado, tendrás que definir un objeto del tipo DataTable que
será donde estén los datos que hay en la tabla de Clientes:

‘ El DataTable lo necesitamos a nivel del formulario

Private dt As DataTable
330 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Para obtener esos datos y llenar la tabla, necesitas un SqlDataAdapter, como es posible que use
otras cosas, lo mejor es añadir una importación al espacio de nombres en el que está definido el
adaptador:

Imports [Link]
Imports [Link]

El adaptador (recuerda que la base es de SQL Server), lo declaramos de esta forma:

‘ El adapatador para obtener los datos

Private da As SqlDataAdapter

También necesitas la cadena de conexión a la base de datos, la base de datos será la base de datos
Northwind y el servidor pondré punto, para no confundir a nadie (UD. En su casa pondrán el nombre
del servidor), por tanto la cadena será de la siguiente manera:

‘ La cadena de conexión
Private conexion As String = _
“Data Source = .; Initial Catalog=Northwind; “ & _
“Integrated Security=true”

La cadena de selección (la que indica que datos debemos traer de la base de datos), es muy simple:
traemos todos los nombres y apellidos de la tabla Clientes:

‘ La cadena de selección los datos que traeremos de la base de datos.

Private seleccion As String =”SELECT Nombre, Apellidos FROM Clientes”

Cargar los datos

Una vez que tenemos todas las variables definidas, (en realidad solo es necesario definir el DataTable
a nivel de formulario), en el evento Load del formulario cargamos el DataTable con los datos:

Private Sub Form1_Load(ByVal sender As Object, ByVal e As EventArgs) _

Handles [Link]
[Link] = “”
da = New SqlDataAdapter(seleccion, conexion)
dt = New DataTable
[Link](dt)
[Link] = dt
iniciando = False
End Sub

Empezar a buscar los datos según lo escrito

Esto lo hago porque en el evento TextChanged de la caja de textos hago la comprobación de si los
apellidos escritos están en la tabla , si has escrito algo en el diseñador de formularios, eso que hayas
escrito se va a asignar a la propiedad Text de la caja de textos, y cuando el código de asignación se
ejecute, se va a producir el evento TextChanged, Para que lo comprendas mejor, te muestro el código
del evento TextChanged de la caja de textos, que es el que se encarga de hacer la búsqueda en los
datos que tenemos en el objeto DataTable (dt):
 Capítulo 10: Aprendiendo todo sobre [Link] 4.0 331

Private Sub txtApellidos_TextChanged( _

ByVal sender As Object, _
ByVal e As EventArgs) _
Handles [Link]
If iniciando Then Exit Sub
‘ Buscar en el DataTable usando el método Select
‘ que es como un filtro WHERE en una cadena de selección.
‘ El resultado se devuelve como un array de tipo DataRow
Dim filas() As DataRow
‘ Si solo quieres mostrar los que empiecen por lo escrito.
‘ Al escribir “s” se buscarán los que empiecen por esa letra.
filas = [Link](“Apellidos LIKE ‘” & [Link] & “%’”)
‘ Borrar los elementos anteriores
[Link]()
‘ Si hay datos, mostrar los apellidos
If [Link] > 0 Then
‘ Recorrer cada fila y mostrar los apellidos
For Each dr As DataRow In filas
[Link]( dr(“Apellidos”).ToString & “, “ &
dr(“Nombre”).ToString)
Next
End If
End Sub

Ahora inicializamos este variable para poder trabajarla mas tarde.

‘ Para evitar re-entradas en el código

Private iniciando As Boolean = True

Buscar en el campo Apellidos con las letras en cualquier posición

La idea es usar el método Select del objeto DataTable. Ese método espera una expresión al estilo de
la que usaríamos con WHERE en una consulta de SQL, por tanto, podemos usar lo mismo que en esa
cláusula WHERE. En el código anterior, lo que le digo que haga es:

Buscar todas las filas en las que el campo Apellidos “empiece” con el texto indicado. Que traducido al
lenguaje que entiende el método Select es: Apellidos LIKE ‘cadena’

filas = [Link](“Apellidos LIKE ‘%” & [Link] & “%’”)

Como resultado nos mostrar un filtro de información según las letras que vayamos escribiendo en el
textbox(según lo explicado arriba en su funcionamiento)
332 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ahora vamos a Sincronizar el resultado con el Control DataGridView

La idea de este sincronizacion que al dar clic en uno de los nombres de la lista, se seleccione el mismo
elemento del DataGridView y se muestre, vamos que sea visible si hay más datos de los que se
muestran.

Por ejemplo, si escribes la letra S, en la lista tendrás varios nombres, y cuando pulsas en uno de ellos,
ese nombre se busca en el DataGridView y se selecciona, además de hacer que sea visible,

Veamos el código que produce todo este efecto

Private Sub listaApellidos_SelectedIndexChanged( ByVal sender As Object, _

ByVal e As EventArgs) Handles [Link]
If iniciando Then Exit Sub
‘ Al hacer clic, mostrar el dato
[Link] = [Link]
‘ Buscarlo en el DataGridView (de forma manual, no conozco otra forma...)
‘ Eliminar las selecciones anteriores
[Link]()
‘ Recorrer las filas para buscar el Apellido indicado
For Each fila As DataGridViewRow In [Link]
‘ Si es el mismo apellido del textBox

‘ Curiosamente si no son los mismos datos

‘ se produce un error de que [Link](...) es Nothing
‘ En realidad de “curioso” no tiene nada,
‘ es que es la última fila, que está vacía...
If [Link](“Apellidos”).Value Is Nothing _
OrElse [Link] Is Nothing Then
Continue For
End If
‘ Si se quiere tener en cuenta el nombre y los apellidos
Dim i As Integer = [Link](“,”)
If i > -1 Then
‘ En este ejemplo, el formato es Apellidos, Nombre
Dim nombre, apellidos As String
apellidos = [Link](0, i).TrimEnd()
nombre = [Link](i + 1).TrimStart()

If nombre = [Link](“Nombre”).[Link] _
AndAlso apellidos = [Link](“Apellidos”).[Link] Then
‘ Seleccionamos la fila
[Link]([Link]).Selected = True
‘ nos aseguramos de que sea visible
 Capítulo 10: Aprendiendo todo sobre [Link] 4.0 333

[Link] = [Link]
Exit For
End If
Else
If [Link] = [Link](“Apellidos”).[Link] Then
‘ Seleccionamos la fila
[Link]([Link]).Selected = True
‘ nos aseguramos de que sea visible
[Link] = [Link]
Exit For
End If
End If
Next
End Sub

EJEMPLOS DE FORMULARIOS DE MANTENIMIENTOS EN [Link]

Conexiones
Empecemos viendo el tipo de conexión normal que utilizamos, aquel que se puede realizar a través
de los eventos del formulario donde se trabaja o en la creación de un Modulo, para entenderlo mejor
veamos el siguiente ejemplo.

Ejemplo – Conexiones Normales

Para eso haremos la siguiente codificación:

Imports [Link]
Imports [Link]

Public Class FrmConectaCodigo

Private Sub FrmConectaCodigo_Load(ByVal sender As [Link], ByVal e As

[Link]) Handles [Link]
Dim Cn As New SqlConnection( _
“Data Source=.;Initial Catalog=Neptuno;Integrated Security=True”)
Dim Da As New SqlDataAdapter(“Select * from Proveedores”, Cn)
Dim Ds As New DataSet
[Link](Ds)
[Link] = [Link](0).DefaultView
End Sub
End Class
334 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ejemplo - Conexiones a través del [Link]

En este ejemplo vamos a desarrollar la conexión en el objeto appconfig y luego vamos a invocar a
dicho objeto en el evento del formulario.

Veamos el Objeto [Link]

<?xml version=”1.0” encoding=”utf-8” ?>

<configuration>

<connectionStrings>
<add name=”ConectaBD1” connectionString=”Data Source=.;Initial
Catalog=Northwind;Integrated Security=True”/>
<add name=”ConectaNeptuno” connectionString=”Data Source=.;Initial
Catalog=Neptuno;Integrated Security=True”/>
</connectionStrings>

<[Link]>
<sources>
<!-- This section defines the logging configuration for [Link] -->
<source name=”DefaultSource” switchName=”DefaultSwitch”>
<listeners>
<add name=”FileLog”/>
<!-- Uncomment the below section to write to the Application Event
Log -->
<!--<add name=”EventLog”/>-->
</listeners>
</source>
</sources>
<switches>
<add name=”DefaultSwitch” value=”Information” />
</switches>
<sharedListeners>

<add name=”FileLog”
type=”[Link], Microsoft.
VisualBasic, Version=[Link], Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a,
processorArchitecture=MSIL”
initializeData=”FileLogWriter”/>
<!-- Uncomment the below section and replace APPLICATION_NAME with the
name of your application to write to the Application Event Log -->
<!--<add name=”EventLog” type=”[Link]”
initializeData=”APPLICATION_NAME”/> -->

</sharedListeners>
</[Link]>
</configuration>

Ahora vamos a crear el siguiente formulario para poder probar la conexión que hemos realizado, el
diseño es el siguiente:
 Capítulo 10: Aprendiendo todo sobre [Link] 4.0 335

La codificación seria la siguiente:

Imports [Link]
Imports [Link]
Imports [Link]

Public Class Form1

Private Sub Form1_Load(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Dim Cn As New SqlConnection(ConnectionStrings(“ConectaBD1”).ConnectionString)
Dim Da As New SqlDataAdapter
Dim Cmd As New SqlCommand(“Select * from Employees”, Cn)
[Link] = Cmd
Dim Ds As New DataSet
[Link](Ds)
[Link] = [Link](0).DefaultView

End Sub
End Class

Creación de Módulos de ejecución de comandos

Primero vamos a atachar al SQL Server 2008 la base de datos Neptuno.

Ahora Generaremos un Módulo de consulta. El cual se llamara ModGeneral

Imports [Link]
Imports [Link]

Module MdGeneral
Public Cn As New SqlConnection( _
“Data Source=.;Initial Catalog=Neptuno;Integrated Security=True”)
Public Da As New SqlDataAdapter
Public Cmd As New SqlCommand
Public Ds As New DataSet

Public Sub RUNSql(ByVal Comando As String)

[Link] = [Link]
[Link] = Comando
[Link] = Cn
[Link] = Cmd
Ds = New DataSet : [Link](Ds)
End Sub

Public Sub RUNStore(ByVal Nombre As String)

[Link] = [Link]
[Link] = Nombre
[Link] = Cn
[Link] = Cmd
Ds = New DataSet : [Link](Ds)
End Sub
End Module
336 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Mantenimiento de Base de Datos con ADO 4.0

Vamos a realizar los procesos de Mantenimiento, sobre la base de datos Neptuno.

Ejemplo – Mantenimiento de base de datos

Diseñemos este formulario para hacer el mantenimiento

Ahora realizaremos el siguiente código:

Public Class FrmMantenimiento1

Dim Registro, Sw As Integer

Public Sub CargaDatos(ByVal Fila As Integer)

With [Link](0).Rows(Fila)
[Link] = .Item(0).ToString
[Link] = .Item(1).ToString
[Link] = .Item(2).ToString
[Link] = .Item(3).ToString
[Link] = .Item(4)
End With
End Sub

Private Sub FrmMantenimiento1_Load(ByVal sender As [Link], ByVal e As

[Link]) Handles [Link]
RUNSql(“Select * from Personal”) : Registro = 0
CargaDatos(Registro)
Call Bloqueos(Me, False)
End Sub

Private Sub btn3_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) _
Handles [Link], [Link], [Link], [Link]
Select Case [Link]
Case “btn1” : Registro = 0
Case “btn4” : Registro = [Link](0).[Link] - 1
Case “btn2”
Registro -= 1
If Registro < 0 Then Registro = 0
Case “btn3”
Registro += 1
If Registro > [Link](0).[Link] - 1 Then _
Registro = [Link](0).[Link] - 1
End Select
CargaDatos(Registro)
End Sub
 Capítulo 10: Aprendiendo todo sobre [Link] 4.0 337

Private Sub btnNuevo_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Sw = 0
Call Bloqueos(Me, True) : [Link] = False
Dim Num As Integer ‘ P05
[Link]() : [Link]() : [Link]() : [Link]() :
[Link] = Today
Registro = [Link](0).[Link] - 1
Num = _
[Link]([Link](0).Rows(Registro).Item(0).[Link](1,
2))
[Link] = “P” + (Num + 1).ToString(“00”)
[Link]()
End Sub

Private Sub btnEditar_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Sw = 1
Call Bloqueos(Me, True)
[Link] = False
[Link](“Puede Modificar...!!!”, “Aviso”)
End Sub

Private Sub btnGrabar_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Dim Fecha As String = [Link](“MM/dd/yyyy”)
Dim Cad As String
If Sw = 0 Then
Cad = “Insert Personal values(@IdPer,@Ape,@Nom,@Sue,@Fingre)”
Else
Cad = “Update Personal Set Ape=@Ape,Nom=@Nom,Sue=@Sue,Fingre=@Fingre” & _
“ Where IdPer=@IdPer”
End If
[Link]() : [Link] = [Link]
[Link] = Cad : [Link] = Cn
With [Link]
.Add(“@IdPer”, [Link], 3).Value = [Link]
.Add(“@Ape”, [Link], 50).Value = [Link]
.Add(“@Nom”, [Link], 40).Value = [Link]
.Add(“@Sue”, [Link]).Value = [Link]([Link])
.Add(“@Fingre”, [Link]).Value = [Link]
End With
Dim N As Integer = [Link]()
If N = 1 And Sw = 0 Then
[Link](“Registro GRABADO.....!!!!”)
ElseIf N = 1 And Sw = 1 Then
[Link](“Registro Actualizado.....!!!!!”)
Else
[Link](“Error en la TRANSACCION..!!!”)
End If
[Link]() : [Link]()
RUNSql(“Select * from Personal”)
If Sw = 0 Then Registro = [Link](0).[Link] - 1
Call Bloqueos(Me, False)
End Sub

Private Sub btnCancelar_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
If Sw = 0 Then Registro = 0
CargaDatos(Registro)
Call Bloqueos(Me, False)
End Sub
338 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Private Sub btnBorrar_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]

If [Link](“Seguro de BORRAR ?”, “Aviso”, _

[Link], [Link]) = _
[Link] Then
Dim cad As String = “Delete Personal Where IdPer=’” & [Link] & “’”
[Link]()
[Link] = [Link] : [Link] = cad
[Link] = Cn
Dim N As Integer = [Link]
[Link]()
If N = 1 Then
[Link](“Registro Eliminado con EXITO...!!!”, “AVISO”)
Registro = 0 : CargaDatos(Registro)
Else
[Link](“Problemas en la Eliminación...!!!”, “AVISO”)
End If
RUNSql(“Select * from Personal”)
End If
End Sub

LINQ para Visual Sudio 2010

LINQ define operadores de consulta estándar que permiten a lenguajes habilitados con LINQ filtrar,
enumerar y crear proyecciones de varios tipos de colecciones usando la misma sintaxis. Tales
colecciones pueden incluir arreglos (vectores), clases e numerables, XML, conjuntos de datos desde
bases de datos relacionales y orígenes de datos de terceros. El proyecto LINQ usa características de la
versión 2.0 del .NET Framework, nuevos ensamblados relacionados con LINQ, y extensiones para los
lenguajes C# y Visual Basic .NET. Microsoft ha distribuido una versión previa del LINQ, consistente de
estas bibliotecas y compiladores para C# 4.0 y Visual Basic 10. Otros lenguajes, como F# han anunciado
brindar soporte.

El objetivo de crear LINQ es permitir que todo el código hecho en Visual Studio (incluidas las llamadas
a bases de datos, datasets, XMLs) sean también orientados a objetos. Antes de LINQ, la manipulación
de datos externos tenía un concepto más estructurado que orientado a objetos. Además LINQ trata de
facilitar y estandarizar el acceso a dichos objetos.
 Capítulo 10: Aprendiendo todo sobre [Link] 4.0 339

Puede utilizar LINQ mediante el control LinqDataSource, mediante el control ObjectDataSource o

creando consultas LINQ.
• Control Linqdatasource: El control LinqDataSource proporciona una manera fácil de conectar a
los datos de una base de datos o a una recolección de datos en memoria como una matriz. El
control crea dinámicamente las consultas LINQ a partir de los valores proporcionados mediante
declaración.

Al recuperar datos de una clase de contexto de datos LINQ to SQL, también puede configurar un control
LinqDataSource para administrar las operaciones de actualización, inserción y eliminación. El control
realiza estas tareas sin requerir que se escriban comandos SQL para ello.

Ejemplo:
Para mostrar los datos en una página web, enlace un control enlazado a datos al control LinqDataSource.
Los controles GridView y DetailsView (son ejemplos de controles enlazados a datos).

En el ejemplo siguiente se muestra el marcado de un control LinqDataSource que conecta con la base
de datos AdventureWorks. Devuelve los registros de la tabla Contact cuya propiedad EmailPromotion
tiene un valor igual a 1.

Mostraremos el marcado de un Control LinqDataSource que conecta con la base de datos

AdventureWorks. Devuelve los registros de la tabla Contact cuya propiedad EmailPromotion tiene un
valor igual a 1.

<asp:LinqDataSource
ContextTypeName=”AdventureWorksDataContext”
TableName=”Contacts” Where=”EmailPromotion=1”
ID=”LinqDataSource1” runat=”server”>
</asp:LinqDataSource>

• Control Objectdatasource: El control ObjectDataSource se utiliza cuando se desea interactuar con

los datos de una manera más compleja que la que permite el control LinqDataSource. Por ejemplo,
puede crear un método de actualización que permita establecer valores en tablas combinadas.

El control ObjectDataSource se puede utilizar con una clase LINQ to SQL. Para ello, se establece la
propiedad TypeName en el nombre de la clase de contexto de datos. También se establecen los
métodos SelectMethod, UpdateMethod, InsertMethod y DeleteMethod en los métodos de la clase de
contexto de datos que realizan las operaciones correspondientes.

Si utiliza la ejecución diferida de consultas con el control ObjectDataSource, debe crear un controlador
de eventos para el evento ObjectDisposing con el fin de cancelar la eliminación de la clase de contexto
de datos. Este paso es necesario porque LINQ to SQL admite la ejecución diferida, mientras que el
control ObjectDataSource intenta eliminar el contexto de datos después de la operación Select.

CONSULTAS LINQ: Puede incluir consultas LINQ en una página web sin utilizar un control de origen
de datos. Puede utilizar una consulta LINQ si necesita utilizar un operador de consulta que no está
disponible en el control LinqDataSource. También puede utilizarlo si desea mostrar datos de sólo
lectura en un control enlazado a datos sin el procesamiento necesario para crear un control de origen
de datos. Para obtener una lista de los operadores de consulta que están disponibles en el control
LinqDataSource, vea Información general sobre el control de servidor web LinqDataSource.
340 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

TIPOS DE LINQ
LINQ to SQL
LINQ to SQL es una implementación de O/RM(object relational mapping, mapeador de objetos
relacionales) nos permite modelar bases de datos relacionales con clases de .NET. Podemos consultar
bases de datos con LINQ, así como actualizar/añadir/borrar datos de ellas.

Modelando bases de datos con LINQ to SQL: Visual Studio viene con un diseñador de LINQ to SQL
que nos aporta una forma fácil de modelar y visualizar una base de datos como un modelo de objeto
de LINQ to SQL. Usando ese diseñador LINQ to SQL puedo crear fácilmente una representación de la
base de datos Northwind. Para poder hacer uso de esta API y aprovechar todas las características de la
misma debemos hacer referencia al ensamble [Link] y en código al namespace System.
[Link]

LINQ to Objects
Es el nombre que recibe la API para los operadores de consulta estandard. Este permite hacer consultas
en arreglos y colecciones de datos en memoria.

Los operadores estandard de consulta son metodos estaticos de la clase estatica [Link].
Enumerable, la cual se utiliza para crear consultas hacia objetos.

LINQ to DataSets
Este es el nombre que recibe la API para el manejo de DataSets. Muchos desarrolladores tienen mucho
código existente para el uso de datasets.

Aquellos que no quieran quedarse rezagados, no necesitaran reescribir todo su código para aprovechar
las ventajas de LINQ

LINQ to Entities
LINQ para entidades es un API alternativa utilizada para interactuar con bases de datos.

Esta separa el modelo de la base de datos de la base de datos física insertando un mapeo lógico entre
los dos.

LINQ to XML
Esta API se utiliza para trabajar con XML.

En versiones previas de LINQ fue conocida como Xlinq.

Para poder aprovechar las ventajas de esta API hay que hacer referencia al ensamble [Link].
dll y en código al namespace [Link]

Ejemplo – Aprendiendo a Trabajar con LINQ

Se dará el siguiente ejemplo haciendo uso del asistente que trae Visual Studio 2010:

Seguiremos los siguientes pasos:

1. Creamos una solución en blanco en la carpeta LINQ.
2. Creamos un sitio WEB.
 Capítulo 10: Aprendiendo todo sobre [Link] 4.0 341

3. Adicionamos una carpeta App_Code: (Funciona como la carpeta Bin, salvo que se puede
almacenar código fuente en lugar de código compilado. La carpeta App_Code y su estado
especial en una aplicación Web [Link] permiten crear clases personalizadas y otros archivos
que sólo contienen código fuente, y utilizarlos en la aplicación Web sin tener que compilarlos
independientemente.)

Añadiendo la Carpeta App Code

Adicionamos un nuevo elemento Linq to SQL y le ponemos de nombre BASE_LINQ.

342 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Usando ese diseñador LINQ to SQL puedo crear fácilmente una representación de la base de datos
“Neptuno”, usaremos las tablas categoría y Neptuno para hacer un ejemplo sencillo:

Con esta acción debemos tener tres nuevos archivos en el proyecto.

• BASE_LINQ.dbml - es archivo xml que define el mapeo.
• BASE_LINQ.[Link] - es un archivo xml que utiliza el diseñador.
• BASE_LINQ.[Link]. - archivo de C# donde se definen las clases y el contexto (la conexión).

Realizaremos esta aplicación en el cual seleccionaremos una categoría del combo y en el gridview
veremos los productos que pertenezcan a esa categoría:
 Capítulo 10: Aprendiendo todo sobre [Link] 4.0 343

Seleccionamos el combo y elegimos un origen de tipo de dato, en este caso seleccionamos el LINQ. Le
ponemos como nombre BASE.

Seleccionaremos la opcion del LINQ, para empezar a realizar el proceso

Ahora seleccionaremos las siguientes opciones:

344 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Nos aparecerán en el primer combo aquellas tablas que hemos seleccionado en el Linq to SQL, en este
caso usaremos la tabla categoría y seleccionamos aquellos campos que usaremos para llenar nuestro
combo. Y finalmente finish.

En este cuadro seleccionamos el campo que queremos que sea en el combo y los valores que tendrán.

Al ejecutar este será nuestro resultado. Nuestro combo estará lleno con las categorías correspondientes.
 Capítulo 10: Aprendiendo todo sobre [Link] 4.0 345

Ahora, llenaremos nuestro Gridview con los productos de acuerdo a la categoría seleccionada, para
ello, realizaremos los mismos pasos que realizamos en el combo, pero a nuestro nuevo LINQ lo
llamaremos BASE2.

Cuando lleguemos este cuadro, seleccionaremos la tabla productos y de igual manera los campos que
mostraremos o usaremos, pero ahora seleccionamos el botón where para indicar el campo que dará
la condición, en este ejemplo será el campo idcategoria.

Y por último seleccionamos el botón adicionar. Antes de ejecutar daremos un repaso amuestro ejercicio
en el cual vemos cada uno de los LINQ creados para cada control: BASE Y BASE2.
346 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Este será la presentación final, con nuestro pequeño ejemplo implementado seleccionamos una
categoría del combo y en el Gridview veremos los productos que pertenecen a la categoría.
 CAPÍTULO

11
Crystal Report
con [Link] 4.0
 CAPÍTULO

Crystal Report
11 con [Link] 4.0
UTILIZANDO CRISTAL REPORT
Crystal Reports es el generador de reporte por excelencia de Visual Basic desde versiones anteriores a
.NET. Esta no es la primera vez que se distribuye una versión de este generador de reporte junto a una
versión de Visual Studio.

Cristal es un producto creado en su esencia orientado al usuario final; es decir que un ejecutivo pueda
crear sus propios informes sin necesidad de asistencia de un desarrollador.

Al igual que desde el ambiente de desarrollo de Visual Studio, también podemos crear nuestros
reportes desde el ambiente de desarrollo de Crystal Reports y luego ejecutarlo desde nuestro proyecto
VB .NET.

Los Reportes desarrollados bajo el ambiente de Crystal Reports pueden ser compilados a .EXE para
poder ser ejecutados luego dentro de nuestro proyecto.

Crear un nuevo procedimiento almacenado desde el explorador de servidores:

Cambiar el nombre del procedimiento almacenado a SS_ListadoProductos, luego nos vamos a Insertar
SQL dando click cderecho sobre el area de codigo:
350 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Desde el cual agregaremos las siguientes tablas Categories y Products

Luego seleccionar los siguientes campos como se muestra en el grafico siguiente:

Al dar aceptar generaremos la siguiente consulta y guardamos el Procedimiento almacenado:

 Capítulo 11: Crystal Report con [Link] 4.0 351

Para crear el informe de Crystal Report seleccionamos un nuevo elemento de Crystal Report con el
nombre crpListadoProductos.

Seleccionamos luego una plantilla estándar como se muestra a continuación:

Tipo de Creación:
Usar Asistente de Informes:
Es una especie de Wizard que nos guía paso a paso durante la creación del reporte.

Como Informe en Blanco:

Despliega la interfaz de desarrollo de reportes en blanco para que creemos nuestro reporte sin
asistencia.
352 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

A partir de un informe existente:

Nos permite crear un reporte a partir de otro ya existente; al seleccionar esta opción nos pide la
localización del archivo .RPT que queremos utilizar, y crea una copia de este reporte.

Luego nos presenta los diferentes tipos de reportes que podemos crear a continuación describo cada
uno de ellos:

Standard:
Este se utiliza para crear reportes tipos listas, máster/detalle y/o cualquier otro reporte común; ésta
es la opción más utilizada.

Tablas Cruzadas:
Este es un estilo de reporte con valores cruzados.

Etiquetas:
Este se utiliza para generar etiquetas para cartas.

Luego seleccionar el origen de datos creado como sigue a continuación:

Datos del Proyecto:

En esta carpeta se despliegan las diferentes conexiones que se encuentren activas en el proyecto
actual; despliega 2 sub carpetas, la primera es “[Link] DataSets”, donde se despliegan las diferentes
estructuras de los DataSet que se encuentren dentro del proyecto; y la segunda despliega los diferentes
objetos conexión que se encuentren activos.
 Capítulo 11: Crystal Report con [Link] 4.0 353

Luego seleccionaremos todos los campos a mostrar:

Este informe será agrupado por los campos CategoryID:

354 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Este informe será totalizado por los campos UnitPrice, UnitsInStock y UnitsOnOrder

Este informe será ordenado por el grupo creado y seleccionamos en finalizar:

 Capítulo 11: Crystal Report con [Link] 4.0 355

Al realizar el diseño el informe podría quedar como sigue:

Crear un formulario con el nombre frmReporte en el cual agregamos desde el cuadro de herramientas
el control ReportViewer con el nombre rptReporteCat que será el visualizador del informe creado.
356 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Mostrando el Reporte
Dentro del formulario creamos lo siguiente, como si quisiéramos mostrar información en un DataGridView:

Para mostrar el reporte agregamos lo siguiente:

Ejecución del Reporte:

 Capítulo 11: Crystal Report con [Link] 4.0 357

Esquema de Trabajo:

ReportSource

SetDataSource

DataSet

MANEJO DE CRYSTAL REPORT

Ejemplo: Como ya hemos visto en el ejemplo anterior, es fácil crear un reporte utilizando el Crystal
Report, ahora continuando otro ejemplo de manejo del Cristal Report desde Visual Studio. net

Para manejar el Cristal Report:

1. En la opción Tools, seleccione la opción Connect to DataBase

2. En la Ventana Server Explorer debemos añadir una nueva conexión:

Clic derecho en DataConnection,

Y luego se realiza lo siguiente, se crea una nueva connection

358 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

En la ventana Add Connection debemos definir la conexión a la Base de Datos:

En el Server Name colocar un punto (servidor local)

• Seleccione la opción Autentificación Windows o si conoce los datos seleccione SQL Server
Authentication, y pone:
• El user name es XXX
• El password es XXX
• Seleccione la Base de datos el cual será Ventas, presione el botón OK.

En el Server Explorer se visualiza la conexión

 Capítulo 11: Crystal Report con [Link] 4.0 359

REPORTE DESDE UNA TABLA

Para realizar un reporte Simple, realice los siguientes pasos

1. Agregar un DataSet a la Aplicación llamado: DsReportes, presione el botón Add

Para agregar la tabla de Clientes, despliegue la conexión y luego despliegue la carpeta TABLES, arrastre
la tabla Clientes

Al arrastrar la Tabla, se visualiza en el DataSet, el cual se crea un TableAdapter llamado Clientes

A continuación procedemos a crear el Reporte utilizando el Cristal Report

360 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

En el proyecto:
• Agregue Nuevo Item
• Seleccione el Item Cristal Report
• Asigne el nombre [Link]

Presione el botón Add

En la galería del Cristal Report:

• Seleccione la opción Using the report Wizard para trabajar con el Asistente.
• Elegir la opción Standard para elaborar listados y reportes
• Presione el botón OK
 Capítulo 11: Crystal Report con [Link] 4.0 361

En la ventana Data, seleccione la carpeta [Link] DataSets; despliegue el DataSet DsReportes, el cual
se visualiza la tabla clientes.

Arrastre la tabla de clientes a la lista Selected Tables, tal como se muestra en la figura.

Luego presione el botón Siguiente

En la Ventana Fields, agregue los campos de la tabla.

362 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Presione el botón Finalizar

En el Proyecto se genera el Reporte Clientes

Agregue un formulario, para trabajar con el Cristal report, agregue el control CrystalReportViewer que
se encuentra en la pestaña Cristal Report, al Formulario
 Capítulo 11: Crystal Report con [Link] 4.0 363

Luego Mostraremos el formulario de la siguiente manera:

Ahora veremos la codificación que hemos realizado:

Private Sub Form1_Load(ByVal sender As Object, ByVal e As EventArgs) Handles [Link]

‘Lo primero que hacemos es declarar
‘una instancia del DataSet ds
Dim ds As New DsReportes

‘una instancia del tableAdapter Clientes llamdo tb

Dim tb As New [Link]

‘Lo llenamos con el contenido de la tabla clientes

[Link]([Link](“clientes”))

‘Declaramos una instancia del Reporte

Dim rptClientes As New ReporteClientes

‘Le indicamos al reporte que tome los datos del DataSet

[Link](ds)

‘Le indicamos que debe mostrar rptClientes

[Link] = rptClientes

End Sub
364 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

REPORTE DE PROCEDURES Y PARAMETROS

Para realizar un reporte que utilice un procedimiento Almacenado con Parámetros, realice los
siguientes pasos

Creación del Procedimiento Almacenado

create procedure usp_clientes_nombre

@nombre varchar(50)
As
Select * from Clientes
Where NombreCia Like @nombre+’%’
Go

El Server Explorer visualiza el procedimiento Almacenado, arrastre el procedimiento almacenado al

DataSet, el cual se crea un TableAdapter

Paso 1

Paso 2
 Capítulo 11: Crystal Report con [Link] 4.0 365

Crear un reporte en la Aplicación

En la Galería del Crystal Report, seleccione el Wizard o Asistente y la opción Standard

Presione el botón OK.

366 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

En la Ventana Data, seleccione desde la carpeta [Link] DataSets el DataSet DsReportes, al desplegar
se visualiza el procedimiento almacenado creado

Seleccione el procedimiento Almacenado usp_clientes_nombre, arrastre dicha tabla a la lista Selected

Tables.

Para continuar presione el botón Siguiente.

 Capítulo 11: Crystal Report con [Link] 4.0 367

En la Ventana Fields, seleccione los campos de la tabla seleccionada.

Cuando termine, presione el botón Finalizar.

Al terminar, el Asistente habrá creado el Reporte.

A continuación procedemos a diseñar el IDE para el reporte.

368 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Diseñe el Reporte, tal como se muestra en la Figura.

Ahora para que esto funcione escribamos el siguiente código:

Public Class Form6

‘Declarar una instancia del DataSet ds

Private ds As New DsReportes
‘Declarar la Instancta del TableAdapter
Private tb As New DsReportesTableAdapters.usp_clientes_nombreTableAdapter

Private Sub BTNCONSULTA_Click(ByVal sender As Object, ByVal e As EventArgs) Handles

[Link]
‘Lo llenamos con el contenido de la tabla usp_clientes_nombre tableclientes.
Fill([Link](“usp_clientes_nombre”), [Link])

‘Declaramos una instancia del Reporte

Dim rptClientes As New ReporteClientes

‘Le indicamos al reporte que tome los datos del DataSet

[Link]([Link](“usp_clientes_nombre”))

‘Le indicamos que debe mostrar mi_rptCatClientes

[Link] = rptClientes
End Sub
End Class
 Capítulo 11: Crystal Report con [Link] 4.0 369

REPORTE DE PROCEDURES Y PARAMETROS

Para realizar un reporte que utilice un procedimiento Almacenado con Parámetros, realice los
siguientes pasos

-- Creación del Procedimiento Almacenado

create procedure usp_pedidos_byFechas

@f1 datetime,
@f2 datetime
As
Select * from PedidosCabe
Where FechaPedido between @f1 and @f2
Go

Arrastre la tabla PedidosCabe al DataSet DsReportes desde el Server Explorer, el cual se crea el
TableAdapter.

Para trabajar con el procedimiento Almacenado, se agrega un Query al TableAdapter para crear un
método que permita ejecutarlo.
370 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

En el TableAdapter de PedidosCabe, hacer click derecho y seleccione la opción AddQuery.

El tipo de Comando que utiliza el TableAdapter será Use existing stored procedure.

Seleccione esta opción, presione el botón Next.

 Capítulo 11: Crystal Report con [Link] 4.0 371

Seleccione el procedimiento almacenado creado: usp_pedidos_byfechas.

Se visualiza los campos a visualizar y sus parámetros.

Presione el botón Next.

Seleccione el tipo de retorno, el cual será Tabular (conjunto de registros), presione el botón Next.
372 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Los métodos que se generan en el TableAdapter, asignarles los nombre correctos, tal como se muestra.

Presione el botón Finish.

En el TableAdapter, se habrá definido los métodos para ejecutar el procedimiento almacenado

 Capítulo 11: Crystal Report con [Link] 4.0 373

A continuación defina el Crystal report llamado RptPedidos, donde debera seleccionar desde el
DataSet: dsReportes.

Agregarlo a la tabla seleccionada.

En la ventana Fields, agregue los campos que se van a imprimir.

Luego presione el botón Finish.

Diseñe la interfaz para trabajar con el Reporte.

374 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ahora realizaremos la programación para que esto funcione correctamente:

Public Class Form6

‘Declarar una instancia del DataSet ds

Private ds As New DsReportes
‘Declarar la Instancta del TableAdapter
Private tbped As New [Link]

Private Sub BTNCONSULTA_Click(ByVal sender As Object, ByVal e As

EventArgs) Handles [Link]
‘Lo llenamos con el contenido de la tabla pedidoscabe
[Link]([Link](“pedidoscabe”), [Link], [Link])

‘Declaramos una instancia del Reporte

Dim rpt As New RptPedidos

‘Le indicamos al reporte que tome los datos del DataSet

[Link]([Link](“pedidoscabe”))

‘Le indicamos que debe mostrar rpt

[Link] = rpt
End Sub
End Class

COMO TRABAJAR [Link] 4.0 CON XML

Empezando con XML.
XML al inicio estuvo basado en los siguientes objetivos: Compatibilidad con los estándares del W3C,
extensibilidad, arquitectura para aplicaciones distribuidas, rendimiento e integración estrecha con
[Link].

XML proporciona a los programadores la capacidad de ofrecer datos estructurados de diferentes

aplicaciones al sistema local con el fin de trabajar localmente con ellos (aplicaciones distribuidas).

NET Framework nos proporciona un conjunto de clases que están organizadas en espacios de acuerdo a
sus funcionalidades ofrecidas, como lectura y escritura de documentos XML, validación de documentos
XML, navegación.

En esta sección se ofrece una descripción general de la arquitectura de XML en .NET Framework. Los
objetivos de diseño de las clases XML en .NET Framework son los siguientes:
• Elevada productividad
• Basado en estándares
• Compatibilidad multilingüe
• Extensibilidad
• Arquitectura conectable
• Centrado en el rendimiento, la confiabilidad y la escalabilidad
• Integración con [Link]

Para obtener más información acerca de arquitectura conectable, vea Objetivos de diseño XML en
.NET Framework.
 Capítulo 11: Crystal Report con [Link] 4.0 375

.NET Framework ofrece la posibilidad de diseñar un conjunto integrado de clases XML e innovar en
el entorno XML. Las clases XML que se suministran son elementos básicos de .NET Framework. Estas
clases ofrecen una solución abierta, ínter operable y compatible con estándares para superar las
dificultades a las que se enfrentan actualmente los programadores.

Para más información sobre las clases XML en .NET Framework, consulte los espacios de nombres
[Link], [Link], [Link], y [Link].

Los objetivos de XML en .NET Framework son los siguientes:

• Compatibilidad con los estándares del W3C.
• Extensibilidad.
• Arquitectura conectable.
• Rendimiento.
• Integración estrecha con [Link].

Recordando Cómo se Maneja XML con DataSet.

El DataSet nos proporciona métodos para el trabajo con XML, estos lo podemos definir tanto para
lectura como para escritura, a nivel de XML como de sus respectivos esquemas.

[Link] (Path)
Lee los datos XML del DataSet mediante la ruta del archivo especificado, el método ReadXml ofrece
una forma de leer sólo los datos o los datos de un documento XML.

[Link](Path)
Lee un esquema XML en el DataSet, del archivo especificado. Se debe de usar el método ReadXmlSchema
para leer el esquema para un DataSet y ser mostrado el cual incluye definiciones de tablas, relaciones
y restricciones.

[Link] (Path)
Escribe los datos actuales mostrados desde el DataSet en el archivo indicado. El método WriteXml
ofrece solo de escribir sólo los datos, de un DataSet con todas las DataTables incluidos, en un
documento XML.

[Link] (Path)
Escribe la estructura del DataSet como un esquema XML dentro de la ruta indicada. Se debe utilizar
este método WriteXmlSchema para escribir el esquema para un DataSet en un documento XML. El
esquema XML se escribe mediante el estándar XSD.

Objetos para Trabajar con XML

XmlReader - Representa un lector que proporciona acceso rápido a datos XML, sin almacenamiento en
caché y con desplazamiento sólo hacia delante.
376 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

XmlReader proporciona acceso de sólo lectura y con desplazamiento sólo hacia delante a una secuencia
de datos XML.

XmlWriter - proporciona un mecanismo genérico en un documento XML en un espacio subyacente. Este

espacio puede ser cualquier cosa desde un archivo si se utiliza XmlTextWriter hasta un XmlDocument
si se utiliza XmlNodeWriter. - El uso de XmlWriter como parámetro para métodos que devuelven XML
proporciona una manera robusta de admitir una amplia variedad de posibles tipos de devolución,
entre los que se incluyen secuencias de archivos, cadenas e instancias de XmlDocument.

XmlDocument. - es una implementación del modelo de objetos de documento de W3C (DOM). DOM es
una representación en memoria de un documento XML compuesto por un árbol jerárquico de objetos
XmlNode que representan componentes del documento XML, como elementos, atributos y nodos de
texto. El principal inconveniente de DOM es que su diseño requiere que se cargue en memoria todo el
documento XML.

XPathNavigator - XPathNavigator es un cursor de sólo lectura a través de orígenes de datos XML. Un

cursor XML funciona como una lente que sólo enfoca un nodo XML a la vez, incluso el cursor se puede
colocar en cualquier parte del documento XML en cualquier momento.

TRABAJANDO CON XML – Ejemplo Inicial

Para empezar a trabajar con XML, vamos a realizar un ejemplo sencillo, en cual cargaremos informacion
de la base de datos y luego lo grabaremos en un archivo xml, vamos a crear un formulario al cual se le
van a adcionar los siguientes Objetos:

Objeto Propiedad Name Propiedad Text

Button 1 btnCargar Cargar de BD
Button 2 btnLeer Leer XML
Button 3 btnGrabar Grabar XML
DataGridView DataGridView1 -------------

El resultado sera de la siguiente manera:

 Capítulo 11: Crystal Report con [Link] 4.0 377

Para poder realizar esto debemos codifcar los siguientes metodos:

Declaracion del los NameSpace y de las variables globales

Imports [Link]
Imports [Link]
Public Class Form5
Dim ds As New DataSet

En el boton cargar realizamos la conexion a la base de datos y cargamos el DataGridView

Private Sub btnCargar_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Dim cn As New SqlConnection(“Data Source=.;Initial Catalog=Pubs;Integrated
Security= true”)
Dim Adp As New SqlDataAdapter(“Select * from Authors”, cn)
[Link](ds, “Authors”)
[Link] = [Link](“Authors”)
End Sub

En este evento nosotros vamos a Grabar los datos cargados de la base de datos en un archivo XML

Private Sub btnGrabar_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Dim ruta As String
Dim saveFile As New SaveFileDialog ‘Cuadro de Dialogo
‘Abrir el cuadro de dialogo y esperar que de click en grabar
If [Link]() = [Link] Then
ruta = [Link] ‘Capturo la direccion del Archivo XML
[Link](ruta) ‘escribo en el Archivo XML
MsgBox(“Grabacion de Archivo xml es correcta”)
End If

End Sub

Permite leer la informacion guardada en el archivo XML

Private Sub btnLeer_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Dim ruta As String
Dim openfile As New OpenFileDialog
If [Link]() = [Link] Then
ruta = [Link]
[Link]()
[Link](ruta)
[Link] = [Link](0)
End If
End Sub
End Class
378 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Validando un XML – Transportando datos

Crear una carpeta en el proyecto con el nombre Archivos:

Crear un formulario frmValidarXML con el siguiente diseño:

En el ámbito general del formulario crear las siguientes variables:

En el load del formulario debe crear lo siguiente:

 Capítulo 11: Crystal Report con [Link] 4.0 379

Para crear el XML:

Para crear el Esquema:

Probar la creación del XML y Esquema y actualizar el explorador de soluciones:

En el botón validar colocamos lo siguiente:

380 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Probar nuevamente y ejecutar el botón Validar, finalizado esto abrir el archivo XML y cambiar el
nombre del DataSet “Proveedores” por el de “MisProveedores”, ejecutar y seleccionar el botón
validar.
 CAPÍTULO

12
Aplicación desarrolladas con
Visual Studio 2010 y [Link] 4.0
 CAPÍTULO

12
Aplicación desarrolladas con
Visual Studio 2010 y [Link] 4.0

Ejemplo de Mantenimiento utilizando los Objetos SqlCommand y SqlDataReader

Ahora, creamos un modulo en el cual añadimos las dos siguiente lineas que nos permite cargar todas
las clases para la coneccion a la base de datos:

Imports [Link]
Imports [Link]

Luego definimos tres variables publicas dentro del modulo:

Module ModConexion
Dim strcon1 As String = “Initial Catalog = AdventureWorks;Data Source= Server;
integrated security=True;”
Dim strcon As String = “Initial Catalog = BdSistemas;Data Source= Server;
integrated security=True;”
Public cn As New SqlConnection(strcon1)
Public cnx As New SqlConnection(strcon)
Public xDataReader As SqlDataReader
End Module

Y Modificaremos el formulario para que tenga la siguiente apariencia:

384 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Veamos como creamos el codigo para la creacion de la tabla dentro del boton “Crear Tabla” :

Private Sub btnTabla_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Dim xtabla As String = “Create Table Clientes( “ & _
“Codigo Int Not Null Primary Key, “ & _
“Nombres Varchar(25), “ & _
“Apellidos Varchar(25), “ & _
“Direccion Varchar(60), “ & _
“Ingreso Numeric(10,2))”
Try
[Link]()
Dim xcmd As New SqlCommand(xtabla, cnx)
[Link]()
MsgBox(“Tabla ha sido Creada Correctamente”)
Catch ex As Exception
MsgBox([Link])
Finally
[Link]()
End Try
End Sub

Observación: No olvidemos siempre que para utilizar los comandos de [Link] debemo siempre
llamar los namespaces siguientes.

Creación de Stores Procedures para los mantenimientos de los datos:

En el SQLServer en la base BDSistemas, creamos los siguientes stores procedures.

Para la Selección:
CREATE PROCEDURE DBO.SS_CLIENTES
AS
SET NOCOUNT ON
SELECT CODIGO, NOMBRES, APELLIDOS, DIRECCION, INGRESO
FROM CLIENTES
GO

Para la Inserción:
CREATE PROCEDURE DBO.SI_CLIENTES
@CODIGO INT OUTPUT,
@NOMBRES VARCHAR(25),
@APELLIDOS VARCHAR(25),
@DIRECCION VARCHAR(60),
@INGRESO NUMERIC(10,2)
AS
SELECT @CODIGO = COUNT(*)+1 FROM CLIENTES
INSERT INTO CLIENTES (CODIGO, NOMBRES, APELLIDOS, DIRECCION, INGRESO)
VALUES (@CODIGO, @NOMBRES, @APELLIDOS, @DIRECCION, @INGRESO)
RETURN @@ROWCOUNT

GO
 Capítulo 12: Aplicación desarrolladas con Visual Studio 2010 y [Link] 4.0 385

Para la Modificación:
CREATE PROCEDURE DBO.SU_CLIENTES
@CODIGO INT,
@NOMBRES VARCHAR(25),
@APELLIDOS VARCHAR(25),
@DIRECCION VARCHAR(60),
@INGRESO NUMERIC(10,2)
AS
UPDATE CLIENTES
SET NOMBRES = @NOMBRES, APELLIDOS = @APELLIDOS, DIRECCION= @DIRECCION,
INGRESO = @INGRESO
WHERE CODIGO=@CODIGO

Para la Eliminación:
CREATE PROCEDURE DBO.SD_CLIENTES
@CODIGO INT
AS
DELETE CLIENTES WHERE CODIGO= @CODIGO
RETURN @@ROWCOUNT

Ahora crearemos dos funciones que nos permitirán tener el manejo de los procesos:

Private Sub btnRefrescar_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Habilitar(False)
Refrescar()
End Sub

Private Sub Habilitar(ByVal xTipo As Boolean)

[Link] = xTipo
[Link] = xTipo
[Link] = xTipo
[Link] = xTipo
End Sub

Mostrar los Clientes en un Datagrid

Para mostrar la información en el datagridView, escribimos el código en el botón refrescar de esta
forma:

Private Sub Refrescar()

Try
[Link]()
Dim xcmd As New SqlCommand(“SS_Clientes”, cnx)
‘Indicamos que se ejecutara un Store Procedure
[Link] = [Link]
Dim adp As New SqlDataAdapter(xcmd)
Dim table As New DataTable
[Link](table)
[Link] = table
Catch ex As Exception
[Link]()
MsgBox([Link])
Finally
[Link]()
End Try
End Sub
386 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Insertar un nuevo Cliente.

Private Sub btnNuevo_Click(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
‘Nos indicara las filas afectadas
Dim RowsUpadte As Integer
‘Nos indicara el key generado.
Dim intKey As Integer
If [Link] = “Nuevo” Then
Habilitar(True)
[Link] = “Agregar”
ElseIf [Link] = “Agregar” Then
Habilitar(False)
[Link] = “Nuevo”
Try
[Link]()
Dim xcmd As New SqlCommand(“SI_CLIENTES”, cnx)
‘Indicamos que se ejecutara un Store Procedure
With xcmd
.CommandType = [Link]
‘Añadimos el paramatro que nos delvuelve el codigo
.[Link](“@CODIGO”, “”)
.Parameters(0).SqlDbType = [Link]
‘Indicamos que retorna un valor
.Parameters(0).Direction = [Link]
‘Añadimos los siguientes parametros del store
.[Link](“@NOMBRES”, [Link])
.[Link](“@APELLIDOS”, [Link])
.[Link](“@DIRECCION”, [Link])
.[Link](“@INGRESO”, [Link])
‘Ejecuta y Retorna las filas afectadas
RowsUpadte = .ExecuteNonQuery
‘Obtenemos el codigo devuelto
intKey = .Parameters(0).Value
End With
Catch ex As Exception
[Link]()
MsgBox([Link], “Soporte a Sistemas”)
Finally
[Link]()
MsgBox(“Se completo su Solicitud”, “Soporte a Sistemas”)
Refrescar()
End Try
End If
[Link] = “”
[Link] = “”
[Link] = “”
[Link] = “”
End Sub

Seleccionar un Fila de un DataGrid.

Private Sub gridClientes_Click(ByVal sender As Object, _
ByVal e As [Link]) Handles [Link]
With gridClientes
[Link] = .Item(.CurrentRowIndex, 1)
[Link] = .Item(.CurrentRowIndex, 2)
[Link] = .Item(.CurrentRowIndex, 3)
[Link] = .Item(.CurrentRowIndex, 4)
End With
End Sub
 Capítulo 12: Aplicación desarrolladas con Visual Studio 2010 y [Link] 4.0 387

Escribir solo Números

Private Sub txtSueldo_KeyPress(ByVal sender As Object, _
ByVal e As [Link]) Handles [Link]
‘ en la siguiente línea de código se comprueba si el caracter es dígito...
If (Not [Link]([Link])) Then
‘ de igual forma se podría comprobar si es caracter: [Link]
‘ si es un caracter minusculas: [Link] ...etc
If Not ([Link] = [Link]([Link])) Then
[Link] = True ‘ esto invalida la tecla pulsada
End If
End If
End Sub

MANTENIMIENTO DE EMPLEADOS
Vamos a realizar un Mantenimiento completo sobre una tabla existente, tomemos la tabla employee,
de la base de datos NorthWind,

El primer paso es crear los siguientes procedimientos almacenados en la base de datos Northwind,
para poder realizar este mantenimiento:

-----------------------------------------
CREATE PROCEDURE SP_ACTUALIZAR_EMPLEADO
@IDEMPLEADO INT,
@NOMBRE NVARCHAR(10),
@APELLIDOS NVARCHAR(20),
@DIRECCION NVARCHAR(60),
@CARGO NVARCHAR(30),
@FCON DATETIME,
@CIUDAD NVARCHAR(15)
AS
UPDATE EMPLOYEES SET
FIRSTNAME=@NOMBRE, LASTNAME = @APELLIDOS,
ADDRESS = @DIRECCION, TITLE=@CARGO,
HIREDATE=@FCON,
CITY=@CIUDAD
where employeeId=@idEmpleado
-----------------------------
CREATE PROCEDURE SP_ELIMINAR_EMPLEADO
@IDEMPLEADO INT
AS
DELETE EMPLOYEES WHERE EMPLOYEEID = @IDEMPLEADO
--------------------------------
CREATE PROCEDURE SP_INSERTAR_EMPLEADO
@NOMBRE NVARCHAR(10),
388 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

@APELLIDOS NVARCHAR(20),
@DIRECCION NVARCHAR(60),
@CARGO NVARCHAR(30),
@FCON DATETIME,
@CIUDAD NVARCHAR(15)
AS
INSERT INTO EMPLOYEES (FIRSTNAME,LASTNAME,ADDRESS,TITLE,HIREDATE,CITY)
VALUES (@NOMBRE,@APELLIDOS,@DIRECCION,@CARGO,@FCON,@CIUDAD)

Ahora empecemos a codificar, empecemos con la declaración de las variables globales

Imports [Link]
Imports [Link]
Public Class frmEmpleado
Inherits [Link]
Código generado por el disaeñador del windows Forms
‘Realizamos la conexión a la base de datos
Dim cn As New SqlConnection(“server=.;database=northwind; Integrated security=sspi”)
‘Seleccionamos con el adaptador la porción de datos que se van a recuperar de
la tabla Employees
Dim daEmployee As New SqlDataAdapter(“Select EmployeeId,firstName,LastName,Addre
ss,Title,HireDate,city from Employees”, cn)
‘Creamos el Dataset que servira de repositorio de los datos recuperados
Dim dsEmployee As New DataSet
‘Creamos un comando que se encargará de ejecutar instrucciones Sql y
‘procedimientos almacenados
Dim cmd As SqlCommand
‘Creamos un parametro que se encargará de enviar datos a los procedimientos
‘almacenados
Dim par As SqlParameter
‘Creamos una variable lógica con el fin de determinar cuando se esta
‘editando o ingresando un nuevo registro
Dim edicion As Bolean

Ahora empecemos creando unas subrutinas para poder llenar los controles textbox del formulario que
hemos creado

‘El método llenarcajas se encargará de mostrar los datos recuperados ‘en cada
caja de texto
Sub llenarcajas()

Dim posicion As Integer

posicion = [Link](dsEmployee, “employees”).Position
With [Link](0).Rows(posicion)
[Link] = .ItemArray(0)
[Link] = .ItemArray(1)
[Link] = .ItemArray(2)
[Link] = .ItemArray(3)
[Link] = .ItemArray(4)
[Link] = .ItemArray(5)
[Link] = .ItemArray(6)
End With
[Link] = dsEmployee
[Link] = “Employees”

End Sub
 Capítulo 12: Aplicación desarrolladas con Visual Studio 2010 y [Link] 4.0 389

El método llenarDesdeGrid hará lo mismo que el método llenarcajas, pero los datos los recuperara de
la grilla cuando el usuario seleccione una fila del DataGridView
Sub llenarDesdeGrid()

With [Link](0).Rows([Link])
[Link] = .ItemArray(0)
[Link] = .ItemArray(1)
[Link] = .ItemArray(2)
[Link] = .ItemArray(3)
[Link] = .ItemArray(4)
[Link] = .ItemArray(5)
[Link] = .ItemArray(6)

End With
End Sub

Crearemos ahora otro procedimiento para limpiar el dataset

‘El método listarempleados se encargará de llenar el dataset con datos actualizados
Sub listarempleados()

[Link]()
[Link](dsEmployee, “employees”)

End Sub

Método que se encargará de limpiar las cajas de texto cuando se quiera añadir un nuevo registro
Sub limpiarcajas()
Dim cajas As Control
For Each cajas In Controls
If TypeOf cajas Is TextBox Then
[Link] = “”
End If
Next
[Link]()
End Sub

Este método se encargará de establecer la posición ordinal del registro actual y el total de registros de
la tabla Employees
Sub contarRegistros()
Dim posicion, totalReg As Integer
posicion = [Link](dsEmployee, “employees”).Position + 1
totalReg = [Link](dsEmployee, “employees”).Count
[Link] = posicion & “ de “ & totalReg
End Sub

Este método se encargará de determinar si las cajas de texto podrán responder o no a algún evento
Sub habilitaCajas(ByVal ws As Boolean)
Dim x As Integer
For x = 0 To [Link] - 1
If TypeOf Controls(x) Is TextBox Then
Controls(x).Enabled = ws
End If
Next
End Sub
390 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Este método hará que los botones de la barra de herramientas puedan o no responder a algún evento

Sub habilitaBotones(ByVal ws As Boolean)

With ToolBar1
.Buttons(0).Enabled = ws ‘nuevo
.Buttons(1).Enabled = ws ‘editar
.Buttons(2).Enabled = Not ws ‘guardar
.Buttons(3).Enabled = ws ‘eliminar
.Buttons(4).Enabled = Not ws ‘cancelar
End With
End Sub

Este método se encargará de habilitar o inhabilitar los botones de desplazamiento

Sub desplazar(ByVal ws As Boolean)

Dim boton As Control
For Each boton In Controls
If TypeOf boton Is Button Then
[Link] = ws
End If
Next
End Sub

Al cargarse el formulario se llamaran a los siguientes métodos

Private Sub frmEmpleado_Load(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]

habilitaCajas(False)
habilitaBotones(True)
listarempleados()
llenarcajas()
[Link] = True
contarRegistros()
End Sub

Ahora realizaremos un Metodo para poder añadir un Nuevo registro

‘Método que permitira añadir un nuevo registro

Sub nuevo()
habilitaCajas(True)
habilitaBotones(False)
desplazar(False)
edicion = False
limpiarcajas()
[Link] = [Link]
End Sub

Método que se encargará de editar un registro existente

Sub editar()
habilitaCajas(True)
habilitaBotones(False)
desplazar(False)
edicion = True
End Sub
 Capítulo 12: Aplicación desarrolladas con Visual Studio 2010 y [Link] 4.0 391

Metodo que se encargará de cancelar la edición de un registro existente o cancelar el ingreso de un

nuevo registro

Sub cancelar()

habilitaCajas(False)
habilitaBotones(True)
desplazar(True)
llenarcajas()

End Sub

Al seleccionar una celda de la grilla se llenarán las cajas de texto con los datos de la fila seleccionada

Private Sub dgEmployee_CurrentCellChanged(ByVal sender As Object, ByVal e As

[Link]) Handles [Link]

llenarDesdeGrid()
contarRegistros()

End Sub

Al seleccionar una fila de la grilla se llenarán las cajas de texto con los datos de la fila seleccionada

Private Sub dgEmployee_Click(ByVal sender As Object, ByVal e As [Link])

Handles [Link]

llenarDesdeGrid()
contarRegistros()

End Sub

Este método se encargará de ejecutar el procedimiento almacenado que permitira añadir un nuevo
empleado

Sub InsertarEmpleado(ByVal nombre As String, ByVal apellidos As String, ByVal

direccion As String, ByVal cargo As String, ByVal fcon As Date, ByVal ciudad As
String)
cmd = New SqlCommand(“sp_insertar_empleado”, cn)
[Link]()
[Link] = [Link]
par = [Link](“@nombre”, [Link], 10)
[Link] = [Link]
[Link] = nombre
par = [Link](“@apellidos”, [Link], 30)
[Link] = [Link]
[Link] = apellidos
par = [Link](“@direccion”, [Link], 50)
[Link] = [Link]
[Link] = direccion
par = [Link](“@cargo”, [Link], 20)
[Link] = [Link]
[Link] = cargo
par = [Link](“@fcon”, [Link])
[Link] = [Link]
[Link] = fcon
par = [Link](“@ciudad”, [Link], 20)
[Link] = [Link]
[Link] = ciudad
[Link]()
[Link]()
End Sub
392 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Este método se encargará de ejecutar el procedimeinto almacenado que permitira actualizar los datos
de un empleado existente o un nuevo empleado

Sub ActualizarEmpleado(ByVal idempleado As Integer, ByVal nombre As String, ByVal

apellidos As String, ByVal direccion As String, ByVal cargo As String, ByVal fcon As
Date, ByVal ciudad As String)

cmd = New SqlCommand(“sp_actualizar_empleado”, cn)

[Link]()
[Link] = [Link]
par = [Link](“@idempleado”, [Link], 4)
[Link] = [Link]
[Link] = idempleado
par = [Link](“@nombre”, [Link], 10)
[Link] = [Link]
[Link] = nombre
par = [Link](“@apellidos”, [Link], 30)
[Link] = [Link]
[Link] = apellidos
par = [Link](“@direccion”, [Link], 50)
[Link] = [Link]
[Link] = direccion
par = [Link](“@cargo”, [Link], 20)
[Link] = [Link]
[Link] = cargo
par = [Link](“@fcon”, [Link])
[Link] = [Link]
[Link] = fcon
par = [Link](“@ciudad”, [Link], 20)
[Link] = [Link]
[Link] = ciudad
[Link]()
[Link]()

End Sub

Este método ejecutará el procedimeinto almacenado que eliminará un empleado

Sub eliminarempleado(ByVal idempleado As Integer)

cmd = New SqlCommand(“sp_eliminar_empleado”, cn)

[Link]()
[Link] = [Link]
par = [Link](“@idempleado”, [Link], 4)
[Link] = [Link]
[Link] = idempleado
[Link]()
[Link]()

End Sub
 Capítulo 12: Aplicación desarrolladas con Visual Studio 2010 y [Link] 4.0 393

Este método invocará los métodos actualizarempleado e insertarempleado

Sub guardar()
habilitaCajas(False)
habilitaBotones(True)
desplazar(True)
If edicion = False Then
If [Link](“¿Desea guardar el” + vbCrLf + “nuevo registro?”,
“NUEVO”, [Link], [Link]) = [Link] Then
InsertarEmpleado([Link], [Link], txtAddress.
Text, [Link], CDate([Link]), [Link])
Else
cancelar()
End If
Else
If [Link](“¿Desea guardar los” + vbCrLf + “cambios realizados?”,
“MODIFICAR”, [Link], [Link]) = [Link]
Then
ActualizarEmpleado(CInt([Link]), [Link],
[Link], [Link], [Link], CDate([Link]), txtCity.
Text)
Else
cancelar()
End If
End If
listarempleados()
llenarcajas()
contarRegistros()
End Sub

Este método invocará al método eliminarempleado

Sub eliminar()
If [Link](“¿Está seguro de eliminar” + vbCrLf + “el registro actual?”,
“ELIMINAR”, [Link], [Link]) = [Link]
Then
eliminarempleado(CInt([Link]))
listarempleados()
llenarcajas()
contarRegistros()
End If
End Sub

Mueve el puntero al siguiente registro

Private Sub btnSiguiente_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
[Link](dsEmployee, “employees”).Position += 1
llenarcajas()
contarRegistros()
End Sub
394 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Mueve el puntero al anterior registro

Private Sub btnAnterior_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]

[Link](dsEmployee, “employees”).Position -= 1
llenarcajas()
contarRegistros()

End Sub

Mueve el puntero al primer registro

Private Sub btnPrimero_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]

[Link](dsEmployee, “employees”).Position = 0
llenarcajas()
contarRegistros()

End Sub

Mueve el puntero al ultimo registro

Private Sub btnUltimo_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
[Link](dsEmployee, “employees”).Position = [Link](dsEmployee,
“Employees”).Count - 1
llenarcajas()
contarRegistros()
End Sub

Invocamos a los métodos de mantenimiento

Private Sub ToolBar1_ButtonClick(ByVal sender As [Link], ByVal e As System.

[Link]) Handles [Link]

Select Case [Link]

Case 0
nuevo()
Case 1
editar()
Case 2
guardar()
Case 3
eliminar()
Case 4
cancelar()
End Select
End Sub
End Class
 Capítulo 12: Aplicación desarrolladas con Visual Studio 2010 y [Link] 4.0 395

Trabajando con Múltiples ConsultasConsultas

Primero vamos a Atachar al SQL Server 2008 la base de datos Neptuno.

Ahora Generaremos un Modulo de consulta. El cual se llamara ModGeneral

Imports [Link]
Imports [Link]

Module MdGeneral
Public Cn As New SqlConnection( _
“Data Source=.;Initial Catalog=Neptuno;Integrated Security=True”)
Public Da As New SqlDataAdapter
Public Cmd As New SqlCommand
Public Ds As New DataSet

Public Sub RUNSql(ByVal Comando As String)

[Link] = [Link]
[Link] = Comando
[Link] = Cn
[Link] = Cmd
Ds = New DataSet : [Link](Ds)
End Sub

Public Sub RUNStore(ByVal Nombre As String)

[Link] = [Link]
[Link] = Nombre
[Link] = Cn
[Link] = Cmd
Ds = New DataSet : [Link](Ds)
End Sub
End Module

Ejemplo – Consulta por el Apellidos

Ahora generaremos el formulario para poder empezar a realizar las consultas respectivas, el formulario
tendrá la siguiente característica:
396 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Empezaremos con el siguiente código:

Reverenciamos los namespace necesarios para la Base de Datos:

Imports [Link]
Imports [Link]

Ahora empezamos a desarrollar el proceso

Public Class FrmConsulta1

Private Sub FrmConsulta1_Load(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
Ds = New DataSet
Cmd = New SqlCommand(“Select * from Empleados”, Cn)
[Link] = Cmd
[Link](Ds)
[Link] = [Link](0)
[Link] = “Apellidos”

Ds = New DataSet
Cmd = New SqlCommand(“Select * from VListaPedidos”, Cn)
[Link] = Cmd : [Link](Ds)
[Link] = [Link](0).DefaultView
[Link] = “Nº de Pedidos: “ + [Link](0).[Link]
End Sub

Private Sub cbEmpleado_SelectedIndexChanged(ByVal sender As [Link], ByVal e

As [Link]) Handles [Link]
Dim Cadena As String = “Select * from VListaPedidos”
If Not [Link] Then
Cadena = Cadena + “ Where Apellidos=’” & [Link] & “’”
End If

Cmd = New SqlCommand(Cadena, Cn)

Ds = New DataSet : [Link] = Cmd : [Link](Ds)
[Link] = [Link](0).DefaultView
[Link] = “Nº de Pedidos: “ + [Link](0).[Link]
End Sub

Private Sub ChkTodos_CheckedChanged(ByVal sender As [Link], ByVal e As

[Link]) Handles [Link]
If [Link] = False Then
[Link] = True
Else : [Link] = False
End If
cbEmpleado_SelectedIndexChanged(sender, e)
End Sub
End Class
 Capítulo 12: Aplicación desarrolladas con Visual Studio 2010 y [Link] 4.0 397

Ejemplo – Consulta por Categoría

Su código es el siguiente:

Imports [Link]
Imports [Link]

Public Class FrmConsulta2

Private Sub FrmConsulta2_Load(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
RUNSql(“Select * from Categorías”)
[Link] = [Link](0) : [Link] =
“NombreCategoría”

RUNSql(“Select * from VListaProductos”)

[Link] = [Link](0).DefaultView

[Link] = “Son : “ + [Link](0).[Link] + “ Productos”

End Sub

Private Sub ChkTodos_CheckedChanged(ByVal sender As [Link], ByVal e As

[Link]) Handles [Link]
If Not [Link] Then
[Link] = True
Else : [Link] = False
End If
cbCategorias_SelectedIndexChanged(sender, e)
End Sub

Private Sub cbCategorias_SelectedIndexChanged(ByVal sender As [Link],

ByVal e As [Link]) Handles [Link]
Dim Cadena As String = “Select * from VListaProductos”
If Not [Link] Then _
Cadena += “ Where NombreCategoría=’” & [Link] & “’”

RUNSql(Cadena)
[Link] = [Link](0).DefaultView
[Link] = “Son : “ + [Link](0).[Link] + “ Productos”

End Sub
End Class
398 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ejemplo – Consultas por rango de Fechas

Ahora vamos a realizar una consulta, que permita realizarlo a nivel de rango de fechas, para esto
vamos a diseñar el siguiente formulario:

Ahora vamos a codificar crear los siguientes eventos para poder realizar las siguientes consultas sobre
las tablas:

Public Class FrmFechas

Private Sub FrmFechas_Load(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
RUNSql(“Select * from VListaPedidos”)
[Link] = [Link](0).DefaultView
[Link] = “Son “ + [Link](0).[Link] + “ Pedidos “
End Sub

Ahora al momento del cambio de check

Private Sub ChkTodos_CheckedChanged(ByVal sender As [Link], ByVal e As

[Link]) Handles [Link]
If Not [Link] Then
[Link] = True : [Link] = True
Else : [Link] = False : [Link] = False : btnVer_Click(sender, e)
End If
End Sub

Private Sub btnVer_Click(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
Dim Cad As String = “Select * from VListaPedidos”
If Not [Link] Then Cad += “ Where FechaPedido Between @Fec1 And @
Fec2”
Da = New [Link](Cad, Cn)

If Not [Link] Then

With [Link]
.Add(“@Fec1”, [Link]).Value = [Link]
 Capítulo 12: Aplicación desarrolladas con Visual Studio 2010 y [Link] 4.0 399

.Add(“@Fec2”, [Link]).Value = [Link]

End With
End If

Ds = New DataSet : [Link](Ds)

[Link] = “Son “ + [Link](0).[Link] + “ Pedidos “

If [Link](0).[Link] > 0 Then

[Link] = [Link](0).DefaultView
Else
[Link] = Nothing
[Link](“No se encontraron Registros....”, “AVISO”)
End If
End Sub

El formulario en su ejecución seria de la siguiente manera, haciendo un filtro por las fechas

Ejemplo – Consulta Pedidos por Mes

Ahora vamos a crear una consulta que permita poder seleccionar la información según un mes,
veamos como seria el formulario:
400 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Donde nosotros en el listbox seleccionamos el mes y esto se reflejara en el DataGridView, para esto
vamos a realizar el siguiente código:

Public Class FrmPedidosMes

Private Sub FrmPedidosMes_Load(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
For N As Integer = 1 To 12
[Link](StrConv(MonthName(N), [Link]))
Next

RUNSql(“Select * from VListaPedidos”)

[Link] = [Link](0).DefaultView
End Sub
Private Sub ChkTodos_CheckedChanged(ByVal sender As [Link], ByVal e As
[Link]) Handles [Link]
If Not [Link] Then
[Link] = True
Else
[Link] = False
LstMes_SelectedIndexChanged(sender, e)
[Link] = -1
End If
End Sub
Private Sub LstMes_SelectedIndexChanged(ByVal sender As [Link], ByVal e
As [Link]) Handles [Link]
‘ Select * from VlistaPedidos
‘ Where Month(FechaPedido)= Nº
Dim Cad As String = “Select * from VListaPedidos”
If Not [Link] Then _
Cad += “ Where Month(FechaPedido)=@Mes”

Da = New [Link](Cad, Cn)

[Link](“@Mes”, [Link]).Value = LstMes.
SelectedIndex + 1
Ds = New DataSet : [Link](Ds)

[Link] = [Link](0).DefaultView
End Sub

End Class

Dando como resultado cuando se ejecuta la siguiente información que se muestra en el formulario:
 Capítulo 12: Aplicación desarrolladas con Visual Studio 2010 y [Link] 4.0 401

Ejemplo – Consulta Múltiple

Bueno vamos a crear ahora una consulta múltiple, lo primero que debemos hacer es crear los siguientes
procedimientos en la base de datos Neptuno:

Procedimientos Almacenados
-- Proc 1
Create Proc sp_ListaClientes
As
Select * from Clientes

-- Proc 2
Create Proc sp_ListaEmpleados
As
Select * from Empleados

-- Proc 3
Create Proc sp_ListaPedidos
As
Select * from Pedidos

-- Proc 4
Create Proc sp_ListaPedidosVarios
@NomEmp VarChar(45), @NomCli VarChar(60),
@Fec1 DateTime, @Fec2 DateTime,
@Accion Int
As
If @Accion=1
Select * From VListaPedidos Where Apellidos=@NomEmp
If @Accion=2
Select * From VListaPedidos Where NombreCompañía=@Nomcli
If @Accion=3
Select * From VListaPedidos
Where FechaPedido Between @Fec1 And @Fec2
If @Accion=4
Select * From VListaPedidos Where Apellidos=@NomEmp And
FechaPedido Between @Fec1 And @Fec2
If @Accion=5
Select * From VListaPedidos Where NombreCompañía=@Nomcli And
FechaPedido Between @Fec1 And @Fec2
If @Accion=6
Select * From VListaPedidos Where Apellidos=@NomEmp And
NombreCompañía=@Nomcli And FechaPedido Between @Fec1 And @Fec2
If @Accion=7
Select * From VListaPedidos

Ahora vamos a diseñar el siguiente formulario:

402 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Antes que nada vamos a explicar como trabaja sus filtros, cada uno de ellos permite habilitar los
campos que se encuentran a su derecha para poder seleccionar los valores correspondientes, y cuando
lo hayamos echo, damos clic en el botón Visualizar, ahora vamos a ver los códigos que corresponden
a dichas opciones de filtro:

Ahora declaramos los namespace y declaramos las siguientes variables globales, que necesitamos en
el código:
Imports [Link]
Imports [Link]
Public Class FrmStoreVarios
Dim Accion As Integer

Ahora creamos la siguiente subrutina:

Sub Muestra()
If [Link](0).[Link] > 0 Then
[Link] = “ Son : “ + [Link](0).[Link] + “ Registros”
Else
[Link] = Nothing
[Link] = “ No Existen Registros....!!! “
End If
End Sub

Ahora realizaremos el script de los siguientes controles:

Private Sub FrmStoreVarios_Load(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
RUNStore(“sp_ListaClientes”)
[Link] = [Link](0) : [Link] =
“NombreCompañía”
RUNStore(“sp_ListaEmpleados”)
[Link] = [Link](0) : [Link] = “Apellidos”
RUNStore(“sp_ListaPedidos”)
[Link] = [Link](0).DefaultView
Muestra()
End Sub

Private Sub rb1_CheckedChanged(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
[Link] = True
[Link] = False
[Link] = False
[Link] = False
Accion = 1
End Sub

Private Sub rb2_CheckedChanged(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
[Link] = False
[Link] = True
[Link] = False : [Link] = False
Accion = 2
End Sub
Private Sub rb3_CheckedChanged(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
[Link] = False
[Link] = False
[Link] = True : [Link] = True
Accion = 3
End Sub
 Capítulo 12: Aplicación desarrolladas con Visual Studio 2010 y [Link] 4.0 403

Private Sub rb4_CheckedChanged(ByVal sender As [Link], ByVal e As System.

EventArgs) Handles [Link]
[Link] = True : [Link] = False : [Link] = True :
[Link] = True
Accion = 4
End Sub
Private Sub rb5_CheckedChanged(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
[Link] = False : [Link] = True : [Link] = True :
[Link] = True
Accion = 5
End Sub
Private Sub rb6_CheckedChanged(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
[Link] = True : [Link] = True : [Link] = True :
[Link] = True
Accion = 6
End Sub
Private Sub rbTodos_CheckedChanged(ByVal sender As [Link], ByVal e As
[Link]) Handles [Link]
[Link] = False : [Link] = False : [Link] = False :
[Link] = False : Accion = 7
End Sub

Ahora escribamos el siguiente codigo en el Boton Visualizar

Private Sub btnVer_Click(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
Da = New SqlDataAdapter(“sp_ListaPedidosVarios”, Cn)
[Link] = [Link]
With [Link]
.Add(“@NomEmp”, [Link], 45).Value = [Link]
.Add(“@NomCli”, [Link], 60).Value = [Link]
.Add(“@Fec1”, [Link]).Value = [Link]
.Add(“@Fec2”, [Link]).Value = [Link]
.Add(“@Accion”, [Link]).Value = Accion
End With
Ds = New DataSet : [Link](Ds)
[Link] = [Link](0).DefaultView
End Sub
End Class

En la ejecución quedaría de la siguiente manera:

404 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ejemplo – Consulta Múltiple

Ahora vamos a crear el siguiente formulario, para realizar otra consulta múltiple:

Ahora vamos a realizar el siguiente código utilizando los mismos procedimientos almacenados que
utilizamos en el ejemplo anterior:
Public Class FrmStoreVarios1

Private Sub FrmStoreVarios1_Load(ByVal sender As [Link], ByVal e As

[Link]) Handles [Link]
RUNStore(“sp_ListaClientes”)
[Link] = [Link](0) : [Link] = “NombreContacto”
RUNStore(“sp_ListaEmpleados”)
[Link] = [Link](0) : [Link] = “Apellidos”
RUNStore(“sp_ListaPedidos”)
[Link] = [Link](0).DefaultView
End Sub
Private Sub rbCliente_CheckedChanged(ByVal sender As [Link], ByVal e As
[Link]) Handles [Link]
[Link] = True
[Link] = False
btnVer_Click(sender, e)
End Sub

Private Sub rbVendedor_CheckedChanged(ByVal sender As [Link], ByVal e As

[Link]) Handles [Link]
[Link] = False : [Link] = True
btnVer_Click(sender, e)
End Sub
Private Sub rbCliVen_CheckedChanged(ByVal sender As [Link], ByVal e As
[Link]) Handles [Link]
[Link] = True : [Link] = True
btnVer_Click(sender, e)
End Sub
Private Sub rbTodos_CheckedChanged(ByVal sender As [Link], ByVal e As
[Link]) Handles [Link]
[Link] = False
[Link] = False
btnVer_Click(sender, e)
End Sub
 Capítulo 12: Aplicación desarrolladas con Visual Studio 2010 y [Link] 4.0 405

Ahora vamos a desarrollar el siguiente procedimiento, donde se realizara el proceso principal:

Sub Procede()
[Link] = [Link]
End Sub
Private Sub btnVer_Click(ByVal sender As [Link], ByVal e As System.
EventArgs) Handles [Link]
If [Link] Then
Da = New [Link](“sp_PedidosCliente”, Cn) : Procede()
[Link](“@Cliente”, [Link], 100).
Value = [Link]
ElseIf [Link] Then
Da = New [Link](“sp_PedidosEmpleado”, Cn) : Procede()
[Link](“@Empleado”, [Link], 50).
Value = [Link]
ElseIf [Link] Then
Da = New [Link](“sp_Pedidos_Cli_Emp”, Cn) : Procede()
With [Link]
.Add(“@Cliente”, [Link], 100).Value = [Link]
.Add(“@Empleado”, [Link], 50).Value = [Link]
End With
Else : RUNStore(“sp_ListaPedidos”)
End If
Ds = New DataSet : [Link](Ds)
If [Link](0).[Link] > 0 Then
[Link] = [Link](0).DefaultView
Else
[Link] = Nothing : [Link](“No hay Registros...!!!”,
“AVISO”)
End If
End Sub
 CAPÍTULO

13
Aprendiendo [Link] en 2010
 CAPÍTULO

13 Aprendiendo
[Link] en 2010
INTRODUCCIÓN DE [Link]

[Link], forma parte de .NET Framework, que proporciona clases y herramientas para crear
Aplicaciones Web dinámicas.

[Link] es un marco de trabajo de programación generado en Common Language Runtime que puede
utilizarse en un servidor para generar aplicaciones Web

[Link] se basa en un modelo de desarrollo Web unificado que incluye los servicios necesarios para
crear Aplicaciones Web empresariales con código mínimo y aplicaciones tan sencillas y dinámicas con
los nuevos controles que nos proporciona, también permite acceder a las clases propias del .NET
Framework.

El código de las aplicaciones puede escribirse en cualquier lenguaje compatible con el Common
Language Runtime. [Link] ofrece varias ventajas importantes acerca de los modelos de programación
Web anteriores:

Mejor rendimiento. [Link] es un código de Common Language Runtime compilado que se ejecuta
en el servidor.
410 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Compatibilidad con herramientas de primer nivel

La edición WYSIWYG, los controles de servidor de arrastrar y colocar y la implementación automática
son sólo algunas de las características que proporciona esta eficaz herramienta.

Eficacia y flexibilidad. Debido a que [Link] se basa en Common Language Runtime, la eficacia y la
flexibilidad de toda esa plataforma se encuentra disponible para los programadores de aplicaciones Web.

La interoperabilidad de Common Language Runtime garantiza que la inversión existente en

programación basada en COM se conserva al migrar a [Link].

Simplicidad. [Link] facilita la realización de tareas comunes, desde el sencillo envío de formularios y
la autenticación del cliente hasta la implementación y la configuración .de sitios. Por ejemplo, el marco
de trabajo de página de [Link] permite generar.

Seguridad. Con la autenticación de Windows integrada y la configuración por aplicación, se puede

tener la completa seguridad de que las aplicaciones están a salvo.

Una de las cosas importantes antes de ver lo que son los web forms, entender un poco la evolución por
las que han pasado las paginas web:
1. Primero fueron las páginas estáticas, las que mayormente eran desarrolladas en Html, Muestran
información estática sin ningún elemento variable (no incluyo los gráficos).
2. Páginas con programación en el cliente. En este caso las páginas incorporan pequeños programas
que se ejecutan en el cliente (Internet Explorer, Firefox, Opera...) y no en el servidor (ASP, [Link]
o Apache). Esta programación suele ser entrada de datos y algún efecto visual. Normalmente están
realizadas con el lenguaje JavaScript.
3. Páginas con programación de servidor. Este es el caso que nos ocupa, se envían unos datos al
servidor (consulta de un número de DNI) y éste nos devuelve una tabla con el resultado. Esto
se puede hacer con muchos programas, por ejemplo en el sistema operativo Linux se utiliza el
PHP cuyos resultados son superiores a las viejas páginas ASP pero muy inferiores a nuestras
nuevas páginas [Link]. Los lenguajes de programación que se ejecutan en el servidor, tambien
llamado del “lado del servidor” son:
 Capítulo 13: Aprendiendo [Link] en 2010 411

• ASP (antigua tecnología de Microsoft) ó Active Server Pages

• [Link], la nueva tecnología de páginas de servidor basada en .NET
• PHP, lenguaje utilizado en los servidores Linux
• JSP, tecnología que permite utilizar Java para crear páginas dinámicas
• CGI, antigua tecnología utilizada sobre todo en servidores UNIX

4. Páginas con programas. Hay dos formas de incrustar programas en las páginas web: con Activex
de Microsoft y con el lenguaje Java de Sun. Los dos casos los conocemos de sobra porque están
presentes en muchas de las páginas que vemos por internet, el primero instala en nuestro ordenador
el programa o ActiveX necesario y a partir de ahí la página puede ejecutar esos programas dentro
de ella, por ejemplo las animaciones con Flash utilizan un ActiveX. En el caso de Java se realizan
programas de cualquier tipo ya que es un lenguaje multipropósito y se ejecutan dentro de las
páginas. En contra tiene la velocidad y la dificultad de programar en este lenguaje.

QUE ES UN SERVIDOR WEB

El servidor Web es un programa que corre sobre el servidor que escucha las peticiones HTTP que le
llegan y las satisface. Dependiendo del tipo de la petición, el servidor Web buscará una página Web
o bien ejecutará un programa en el servidor. De cualquier modo, siempre devolverá algún tipo de
resultado HTML al cliente o navegador que realizó la petición.

El servidor Web va a ser fundamental en el desarrollo de las aplicaciones del lado del servidor, server
side applications, que vayamos a construir, ya que se ejecutarán en él.

El Servidor Web se encarga de contestar a estas peticiones de forma adecuada, entregando como
resultado una página Web o información de todo tipo de acuerdo a los comandos solicitados. En este
punto es necesario aclarar lo siguiente: mientras que comúnmente se utiliza la palabra servidor para
referirnos a una computadora con un software servidor instalado, en estricto rigor un servidor es el
software que permite la realización de las funciones descritas.
412 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

LOS WEB FORMS

Las páginas de formularios Web de [Link] es un modelo de programación escalable de Common

Language Runtime que puede utilizarse en el servidor para generar páginas Web dinámicamente.

Basada en la evolución lógica de ASP ([Link] proporciona compatibilidad sintáctica con las
páginas existentes), el marco de trabajo de formularios Web [Link] se ha diseñado específicamente
para tratar varias deficiencias clave del modelo anterior. En particular, proporciona:
• Capacidad para crear y utilizar controles de la interfaz de usuario reutilizables que puedan
encapsular funcionalidades comunes y, así, reducir la cantidad de código que tiene que
escribir el programador de una página.
• Capacidad para que los programadores puedan estructurar limpiamente la lógica de la página
de forma ordenada (no revuelta).
• Capacidad para que las herramientas de desarrollo proporcionen un fuerte soporte de diseño
WYSIWYG (Lo que ve es lo que se imprime) a las páginas (el código ASP existente es opaco para las
herramientas).
 Capítulo 13: Aprendiendo [Link] en 2010 413

Pasos para poder Crear una Aplicación en [Link]

Para poder crear una aplicación, Ingresemos al Visual Studio 2010, seleccionamos el menú File, y
buscamos la selección New Web Site esto nos permitirá crear un sitio Web.

Ahora nos muestra las opciones disponibles

414 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

En nuestro caso queremos crear un sitio web [Link], luego esa es la opción que seleccionamos.
Debajo fíjate que el lenguaje que vamos a utilizar el “Visual Basic” y “Location” indica que es
“File System” es decir, una carpeta normal de nuestro disco duro. Mas adelante ya veremos todas
las opciones ya que tendremos que crear y publicar nuestros sitios web en nuestro flamante IIS
instalado.

Así que hacemos clic en la parte central y abajo para poner la pantalla en la vista de diseño en lugar de
la del código, así que haz clic en “Design”

Y ahora para ejecutarlo podríamos hacerlo de 2 maneras distintas.

1 - La primera de ella es ejecutando la aplicación, esto se logra dando clic en botón ejecutar
 Capítulo 13: Aprendiendo [Link] en 2010 415

Cuando lo ejecutamos de esta manera, nos muestra una ventana que nos avisa que no puede ejecutar
la página porque no tiene configurado el modo de depuración nuestro sitio web. Pero nos ofrece la
posibilidad de activar esto para poder continuar, así que modificará esta opción pulsando en “OK” y
podremos continuar.

Ahora vemos algo raro que nos muestra, si observas la parte de abajo a la derecha nos ha aparecido
este mensaje:

Esto se realiza para poder ejecutar la aplicación, nuestro entorno de desarrollo incorpora un pequeño
servidor web para la depuración y la ejecución de las páginas. No se puede utilizar como servidor web,
es sólo para la prueba de las páginas, así no tenemos que moverlas a un servidor IIS para probarlas.
Luego muy bien, las crearemos aquí y podremos probarlas completamente antes de pasarlas al IIS. Si
te fijas pone:
[Link]

El servidor es “localhost” que es una palabra clave que apunta a nuestro propio equipo y ejecuta el
servidor Web en el puerto 4450 de ahí localhost:4450. Ya sabemos que los servidores Web se ejecutan
en el puerto 80 pero como este es uno de pruebas lo ejecuta en ese puerto, no importa ya que es
para probar las páginas. Y por fin pone en marcha la página predeterminada del sitio Web llamado
“Website2”. Así que muy bien, tenemos en nuestro equipo un pequeño servidor Web para poder
ejecutar las páginas, no hay que configurar nada de este servidor Web porque lo gestiona todo nuestro
entorno.

2 – La segunda forma es solo correr el formulario para estos utilizamos botón derecho y la opción “Ver
en el Browser”
416 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Igual las dos formas de poder ejecutarlo nos muestran el mismo resultado

Listo así de sencillo hemos creado una página Web, ahora si empecemos a complicarnos un poco mas
con la creación de paginas Web.

Archivos Creados al momento de Construir una Aplicación Web

 Capítulo 13: Aprendiendo [Link] en 2010 417

PROGRAMANDO CON [Link]

Utilizar bloques de representación ASP <%%>
[Link] proporciona compatibilidad sintáctica con páginas ASP existentes. Esto incluye compatibilidad
para bloques de representación de código <% %> que pueden entremezclarse con contenido HTML
dentro de un archivo .aspx. Estos bloques de código se ejecutan de arriba a abajo en tiempo de
representación de página.

En el siguiente ejemplo se muestra cómo se pueden utilizar bloques de representación <% %> para
ascender en bucle por un bloque HTML (aumentando el tamaño de fuente cada vez):

I.- Crear una pagina con el nombre BloquesServidor dentro del código HTML colocamos lo siguiente y
lo Ejecutamos

Usando controles de servidor en [Link]

Al utilizar bloques de código <% %> se usa para programar contenido dinámico, estos pueden utilizar
controles de servidor [Link] para programar páginas Web. Los controles de servidor se declaran
dentro de un archivo .aspx mediante etiquetas personalizadas o etiquetas HTML intrínsecas que
contienen un valor de atributo runat=”server”. Las etiquetas HTML intrínsecas las controla uno de los
controles del espacio de nombres [Link].

En el siguiente ejemplo utilizaremos controles de servidor: runat=server. En tiempo de ejecución, estos

controles de servidor generan contenido HTML automáticamente.
418 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Eventos de controles de servidor

Cada control de servidor [Link] puede exponer un modelo de objeto con propiedades, métodos y
eventos. Estos se pueden utilizar con el objetivo para modificar e interactuar limpiamente con la página.

Luego este evento del botón será llamado desde:

Primer Ejemplo de [Link]

En esta oportunidad vamos a realizar un ejercicio, que vamos a programarlo como si fuera una
aplicación Windows. Construyamos la siguiente Webforms:

Dar doble clik sobre el botón agregar y escribimos lo siguiente:

Dim Sprd as String = [Link]
[Link](sPrd)
[Link]
 Capítulo 13: Aprendiendo [Link] en 2010 419

Damos doble Click sobre el Botón y luego escribimos

Dim I as Integer
For I = 0 to [Link] – 1
[Link]([Link](I).Value)
Next
[Link]()

Ahora Damos Doble Click en el Boton y luego escribimos

If [Link] <> -1 Then

[Link]([Link])
[Link]([Link])
End If

Muy parecido a trabajar con aplicaciones Windows, donde definimos todo el script en los eventos de
cada uno de los controles….fácil no, ahora has tu desarrollo los otros 2 botones de regreso.

Ejemplo - Leer Formulario y escribir respuesta

Lee un texto escrito en un formulario y escribe la respuesta en la página web.
El codigo Source es el Siguiente

<%@ Page Language=”VB” AutoEventWireup=”false” CodeFile=”[Link]”

Inherits=”Default3” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN” “[Link]

TR/xhtml1/DTD/[Link]”>

<html xmlns=”[Link]
<head runat=”server”>
<title></title>
<script runat=”server”>
Sub submit(sender As Object, e As EventArgs)
[Link] = “<b>Usted escribio:</b> “ & [Link]
End Sub
</script>
</head>
<body>
<form id=”form1” runat=”server”>
Introduzca un texto:<br />
<textarea id=”textarea1” cols=”35” rows=”6” runat=”server” />
<input id=”Submit1” type=”submit” value=”Submit” OnServerClick=”submit”
runat=”server” />
<p id=”p1” runat=”server” />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
</form>
</body>
</html>
420 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

El resultado seria el siguiente:

Ejemplo - Formatos de Fechas en ASP NET

Aprende a manejar las fechas y a darlas cualquier formato.

<%@ Page Language=”VB” AutoEventWireup=”true” CodeFile=”[Link]”

Inherits=”Default4” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN” “[Link]

TR/xhtml1/DTD/[Link]”>
<%@ Import Namespace=”[Link]”%>
<%@ Import namespace=”[Link]” %>
<html xmlns=”[Link]
<head runat=”server”>
<title>Prueba de Formatos de Fechas</title>
<script runat=”server”>
Sub Page_Load(Src As Object, E As EventArgs)
Dim fechaS as String
Dim miFecha as DateTime = [Link]()
fechaS = [Link](“{0:dd/MM/yyyy}”, miFecha)
[Link] = fechaS
End Sub
</script>
</head>
<body>
<form id=”form1” runat=”server”>
Fecha con formato de hoy en dia, mes y año: <asp:label ID=”fechaId”
runat=”server”></asp:label><br>
</form>
</body>
</html>
 Capítulo 13: Aprendiendo [Link] en 2010 421

Esta seria el valor que devolveria la ejecución

CONTROLES WEB BÁSICOS

Controles Básicos Web

Clase Control Elemento HTML

Label <span>
Button <input type=”submit”> or <input type=”button”>
TextBox <input type=”text”>, <input type=”password”>, or <textarea>
CheckBox <input type=”checkbox”>
RadioButton <input type=”radio”>
Hyperlink <a>
LinkButton <a> with a contained <img> tag
ImageButton <input type=”image”>
Image <img>
ListBox <select size=”X”> where X is the number of rows that are visible
at once
DropDownList <select>
CheckBoxList A list or <table> with multiple <input type=”checkbox”> tags
RadioButtonList A list or <table> with multiple <input type=”radio”> tags
BulletedList <ol> ordered list (numbered) or <ul> unordered list (bulleted)
Panel <div>
Table, TableRow,and TableCell <table>, <tr>, and <td> or <th>
422 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ejemplo - Visualización de un control CheckBox básico

Proporciona un mecanismo para recibir respuestas de tipo verdadero y falso o si o no de los visitantes.

El código para realizar este ejemplo es el siguiente:

<%@ Page Language=”VB” AutoEventWireup=”false” CodeFile=”[Link]” Inherits=”_

Default” %>
<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN” “[Link]
TR/xhtml1/DTD/[Link]”>
<html xmlns=”[Link]
<head runat=”server”>
<title></title>
<script runat=”server”>
Sub SubmitBtn_Click(Sender As Object, E As Eventargs)
If [Link] = “True” Then
[Link](“<script Language=””JavaScript!”” >” & Chr(13) & “<!-”
& Chr(13) & “alert(´se han añadido sus datos a nuestra “ & “-><” & “/” & “SCRIPT>”)
End If
End Sub
</script>
</head>
<body>
<form id=”form1” runat=”server”>
<br> <br>
<asp:checkbox ID=”chkMailingList” Text=”¿Le gustaria que se las llevasemosa
casa la comida que compre?” Checked=”true” BackColor=”#FFFF00”
BorderColor=”#FF0000” BorderWidth=”3” Font-Size=”12pt” Font-Name=”Comic
Sans MS” TextAlign=”Left” runat=”server”/> <br><br>
<asp:checkbox ID=”chkContact” Text=”¿ Le gusta la comida del super?”
Checked=”false” BackColor=”#FFFF00” BorderWidth=”3” Font-Size=”12pt” Font-
Name=”Comic Sans MS” TextAlign=”Right” runat=”server”/>
<br><br>
<asp:button ID=”butOK” Text=”Aceptar” type=”Submit” OnClick=”SubmitBtn_Click”
runat=”server”/>
</form> </body>
</html>
 Capítulo 13: Aprendiendo [Link] en 2010 423

Ejemplo - Utilización del control HTMLinputCheckBox

La página creada para describir esta técnica solicita a los visitantes que respondan dos preguntas de
tipo sí/no a través de controles HTMLInputCheckBox.

Cuando los visitantes envíen la página, verán un texto basado en sus respuestas.
<%@ Page Language=”VB” ContentType=”text/html” ResponseEncoding=”iso-8859-1” %>
<script runat=”server”>
Sub SubmitBtn_Click(Source as Object, E as EventArgs)
[Link] = “”
If ([Link] = True ) Then
[Link] = “ Ha seleccionado el “ & “dibujo. <br>”
End If
If [Link] =True Then
[Link] = “Esta en nuestra lista” & “de contactos. <br>”
end If
end sub
</script>
<html> <head><title>Documento sin t&iacute;tulo</title> </head>
<body bgcolor=”#FFFFFF”>
<form id=”Form1” runat=”server”>
<input type=”checkbox” id=”chekeoeldibujo” runat=”server”>
¿obtener un dibujo gratuito<br />
<input id=”chekeodecontacto” runat=”server” type=”checkbox” checkbox>
¿ desea q se añadan sus datos a la lista de contactos?<br />
<button id=”Button1” runat=”server”
onserverClick=”SubmitBtn_Click”>Enviar</button><br />
<span ID=”mimensage” runat=”server”></span>
<span ID=”mimensage1” runat=”server”></span>
</form>
</body>
</html>

El resultado sería el siguiente, te mostraría la información que es tu has seleccionado:

424 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

CONTROLES WEB AVANZADOS

Panel - Representa un control que actúa como contenedor de otros controles. El control Panel es
un contenedor de otros controles. Resulta especialmente útil si desea generar controles mediante
programación, ocultar o mostrar un grupo de controles o adaptar un grupo de controles.

La propiedad Direction es útil para adaptar el contenido de un control Panel con el fin de mostrar texto
para idiomas que se escriben de derecha a izquierda, como el árabe o el hebreo.

Espacio de nombres: [Link]

Ensamblado: [Link] (en [Link])

Ejemplo – Mostramos como podemos utilizar el Panel, creo un nuevo WebForm, dentro del cual
arrastraremos 2 controles, el Panel y un control checkbox

Luego de haber insertado los controles, debemos cambiar al checkbox la propiedad del AutoPostBack
= trae y la propiedad Checked= true
 Capítulo 13: Aprendiendo [Link] en 2010 425

Luego de esto empezamos a codificar el control Checkbox, ingresando a la propiedad CheckedChanged

Protected Sub CheckBox1_CheckedChanged(ByVal sender As Object, ByVal e As System.

EventArgs) Handles [Link]
[Link] = [Link]
End Sub

Multiview - El control MultiView es un contenedor para un grupo de controles View. Permite definir un
grupo de controles View en el que cada control View contiene controles secundarios. A continuación,
la aplicación puede representar un control View concreto en el cliente basándose en criterios como la
identidad del usuario, las preferencias del usuario e información pasada en un parámetro de cadena
de consulta. El control MultiView también se puede utilizar para crear asistentes. En este escenario,
cada control View contenido en un control MultiView representa un paso o página diferente del
asistente. Este control también se debe utilizar para desarrollar aplicaciones de múltiples pantallas
para dispositivos móviles.

Espacio de nombres: [Link]

Ensamblado: [Link] (en [Link])

Haber realicemos un ejemplo para entender mejor, como trabaja el Multiview, agregamos un control
multiview y dentro de el agregemos 4 controles View

Luego de eso agregamos un control RadioButtonList, y daremos click en su propiedad Edit Items, para
agregar los ítems.
426 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ahora agregamos los 4 ítem que van a ser relacionado a los view(dando clic en el botón Add(agregar)
y modificando la propiedad Text, por el numero de índice al cual pertenece)

Ahora en el control MultiView, modificar la propiedad ActiveViewIndex, para que el primer índice sea
el numero 0

También se debe modificar la propiedad del MultiView el AutoPostBack en trae

Luego se debe codificar el siguiente código:

Protected Sub RadioButtonList1_SelectedIndexChanged(ByVal sender As Object, ByVal e

As [Link]) Handles [Link]
Dim indice As Integer = CInt([Link])
[Link] = indice
End Sub

Y ahora UD puede probar, y ver el funcionamiento de esto.

 Capítulo 13: Aprendiendo [Link] en 2010 427

FileUpload - Muestra un control de cuadro de texto y un botón de búsqueda que permiten a los
usuarios seleccionar un archivo para cargarlo al servidor. La clase FileUpload muestra un control de
cuadro de texto y un botón de búsqueda que permiten a los usuarios seleccionar un archivo en el
cliente y cargarlo en el servidor Web. El usuario especifica el archivo que desea cargar escribiendo su
ruta de acceso completa en el equipo local (por ejemplo, C:\Archivos\[Link]) en el cuadro de texto
del control. También puede seleccionar el archivo haciendo clic en el botón Examinar y buscándolo
después en el cuadro de diálogo Elegir archivo.

Espacio de nombres: [Link]

Ensamblado: [Link] (en [Link])

Para entender este control. Hagamos un ejemplo sencillo, arrastremos sobre el Webform, un control
FileUpLoad y un Button, la página quedara de la siguiente manera

Ahora codificamos lo siguiente en el evento click de button Cargar Archivos

Protected Sub Button2_Click(ByVal sender As Object, ByVal e As [Link])

Handles [Link]
‘Carga el Archivo en el servidor
[Link]([Link](“~/” + [Link]))
End Sub

Calendar - Muestra un calendario de un solo mes que permite al usuario seleccionar fechas y
desplazarse al mes siguiente o al mes anterior. Utilice el control Calendar para mostrar un solo mes de
un calendario en una página Web. El control permite seleccionar fechas y desplazarse al mes siguiente
o al mes anterior. El control Calendar admite todos los tipos [Link] del espacio
de nombres [Link]. Además del calendario gregoriano, también se incluyen calendarios
que utilizan diferentes sistemas de año y mes, como el calendario Hjiri.

Espacio de nombres: [Link]

428 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Ensamblado: [Link] (en [Link])

Haremos un ejemplo sencillo para demostrar como es la funcionabilidad de dicho control, creamos un
nuevo web forms, dentro de el adicionamos un control calender al final se mostraría la pagina de esta
manera:

Una de las propiedades con las cuales cuenta, es la auto formato, que permite cambia de formato al
calendario.
 Capítulo 13: Aprendiendo [Link] en 2010 429

Así se puede elegir cualquiera de ellos y este va a parecer como formato en el calendario

Los controles Avanzados no por ser avanzados son difíciles.

OTRO CONTROL AVANZADO

El Control ADRotator
Este control nos permite publicar imágenes que puedan rotar en forma aleatoria de acuerdo a los
pesos que le indicamos, los principales propiedades de este control es el siguiente:

Primero la estructura interna esta basado en código XML, para tener elementos bien definidos.

Segundo se debe respetar las mayúsculas y minúsculas.

El AdRotator empieza con la etiqueta: <Advertisements>

Cada imagen agregada al control debe empezar con la etiqueta: <Ad>

Por cada imagen agregada debe contener lo siguiente:

<ImageUrl> _ Ubicación física donde se encuentra el Grafico.

<NavigateUrl> _ Enlace a donde apuntara la pagina.

<AlternateText> _ Texto a mostrar sobre el cursor, propiedad ALT de la imagen.

<Impressions> _ Peso que va a tener la imagen para ser mostrada.

<Keyword> _ Nombre relacionado al Grafico.

430 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Para realizar un ejemplo con este control lo primero que vamos a realizar es la creación de un WebForm,
en cual le vamos a adicionar los siguientes controles

Luego vamos a codificar el Botón btnAgregar de una manera sencilla, que me permita validar el usuario
y la clave

Protected Sub btnAgregar_Click(ByVal sender As Object, ByVal e As [Link])

Handles [Link]
If [Link] = xusuario And [Link] = xClave Then
[Link] = “Ingreso al Sistema Correcto ...OK”
Else
[Link] = “NO Ingreso Correctamente al Sistema”
[Link] = “”
[Link] = “”
End If
End Sub

Bueno esta parte es un poco para darle forma a nuestro formulario, ahora insertaremos encima de los
controles un control Adrotator.

Luego de esto en el explorador de soluciones agregaremos una carpeta a la cual llamaremos logo, ahora
anexemos 4 gráficos dentro de esta carpeta, el explorador de soluciones debería quedar de esta manera:

Ahora dentro de la carpeta vamos a crear un archivo XML, para esto presionaremos botón derecho
sobre la carpeta logo, y adicionamos nuevo ítem y elegimos Archivo Xml, donde ingresaremos los
siguientes datos en el Archivo(el archivo se llamara [Link]):

<?xml version=”1.0” encoding=”utf-8” ?>

<Advertisements>
<Ad>
<ImageUrl>[Link]</ImageUrl>
<NavigateUrl>[Link]
<AlternateText>Programacion de Recursos Downloads..</AlternateText>
<Impressions>70</Impressions>
<Keyword>Download</Keyword>
 Capítulo 13: Aprendiendo [Link] en 2010 431

</Ad>
<Ad>
<ImageUrl>[Link]</ImageUrl>
<NavigateUrl>[Link]
<AlternateText>Todo sobre el Sql Server .</AlternateText>
<Impressions>70</Impressions>
<Keyword>PortaL de SQL</Keyword>
</Ad>
<Ad>
<ImageUrl>[Link]</ImageUrl>
<NavigateUrl>[Link]
<AlternateText>Buscador de Servidores</AlternateText>
<Impressions>70</Impressions>
<Keyword>Buscador</Keyword>
</Ad>
</Advertisements>

Se debe respetar las mayúsculas y minúsculas que se utilizan(este archivo es sensitivo)

Luego de esto se debe relacionar el archivo Adrotator con el Archivo XML, para esto en la propiedad
AdvertisementFile se le da la ubicación del Archivo banner. xml

Después de esto solo es necesario ejecutar la página para que se pueda ver el resultado.

Presionando continuamente F5, los gráficos que se encuentran encima del titulo Irán cambiando
según el peso que se le ha dado (impressions)

Nosotros podemos ubicarnos en el grafico y dar clic encima de el y podemos acceder a la pagina
que esta relacionada (la cual se la relaciono en el archivo XML)
432 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

Aplicando Estilos a los Controles WEB

La especificación de Hojas de estilos en cascada(CascadingStyle Sheets, CSS), nos permite definir la
apariencia y aspecto de los elementos de una pagina HTML, entendiendo por elementos las distintas
etiquetas de HTML.

Los controles WEB ofrecen un completo soporte para las hojas de estilo, es decir, podemos aplicar los
estilos de forma similar a como lo hacemos en HTML para personalizar el aspecto de nuestro controles.

Aplicando Estilos a Controles HTML

Por Propiedades
Una de las formas de utilizar estilos con los controles WEB es a través de una serie de propiedades
que representan los prpios controles WEB. Esta propiedades se encuentran tipiadas y representan los
estilos mas frecuentes que pueden aplicarse al control, color, tamaño, letra, color de fondo, etc.

Ejemplo de estilos por Propiedades

<html xmlns=”[Link] >
<head runat=”server”>
<title>Página de Estilos - Por Propeidades</title>
</head>
<body>
<form id=”form1” runat=”server”>
<asp:Label runat=”server” ID=”etiqueta” BackColor=”yellow” BorderColor=”red”
BorderStyle=”Dotted” ForeColor=”Green” Font-Size=”12” Font-Bold=”true”
Font-Italic=”True” Font-Names=”Verdana”>
Aplicando Estilos sobre Controles por Propiedades
</asp:Label>
</form>
</body>
</html>

Por CssClass
Otra forma de aplicar estilos a un control Web es mediante la propiedad CssClass, a esta propiedad
le asiganaremos el nombre de clase que define al estilo que se desea aplicar sobre el control WEB
correspondiente

Ejemplo de estilos CssClass

<html xmlns=”[Link] >
<head runat=”server”>
<title>Página de Estilos - CssClass</title>
<style>
.clase{font:14pt verdana; background-color:yellow;color:red;}
.clase1{font:10pt Arial; background-color:Pink;color:blue;}
</style>
</head>
<body>
<form id=”form1” runat=”server”>
<asp:Label runat=”server” ID=”etiqueta” CssClass=”clase”>Aplicando Estilos</
asp:Label>
<br />
<asp:Label runat=”server” ID=”etiqueta1” CssClass=”clase1”>[Link]</asp:Label>
</form>
</body>
</html>
 Capítulo 13: Aprendiendo [Link] en 2010 433

CSS también defina un atributo de clase que puede puede fijarse a una definición de estilo CSS
contenida en una sección <style>...</style> del documento. El atributo de clase hace más sencillo
definir los estilos una vez y aplicarlos a diferentes etiquetas sin tener que redefinir el estilo. Los estilos
en controles HTML de servidor también se pueden establecer de esta forma, tal y como muestra el
siguiente ejemplo.

Estilos Style
Mediante la propiedad Styl, que es una coleecion que nos permite asignar valores a las distintas
propiedades del estilo del control. En este caso no se realiza ningun tipo de comprobacion para indicar
si la propiedad existe o no, unicamente se va añadiendo al control para luego mostrarse en el codigo
HTML como parte de la propiedad Style del elemento HTML correspondiente

Ejemplo de estilos Style

<html xmlns=”[Link] >

<head runat=”server”>
<title>Página de Estilos - Style</title>
<script language=”vbscript” runat=”server”>
Sub Page_Load(ByVal sender As Object, ByVal e As EventArgs)
[Link](“font-size”) = “12pt”
[Link](“font-family”) = “Comic Sans Ms”
[Link](“background-color”) = “pink”
[Link](“color”) = “red”
[Link](“border-style”) = “Dotted”
[Link](“border-color”) = “blue”
End Sub
</script>
</head>
<body>
<form id=”form1” runat=”server”>
<asp:Label runat=”server” ID=”etiqueta”>Aplicando Estilos Tipo STYLE</asp:Label>
</form>
</body>
</html>

Las etiquetas estándar HTML soportan CSS a través del atributo “style” (estilo), que se puede fijar a
una lista de parejas atributo/valor delimitada por puntos y comas. Para más información sobre los
atributos CSS soportados por el navegador Internet Explorer, visitad la página Referencia de Atributos
CSS del MSDN. Todos los controles HTML de servidor de [Link] pueden aceptar estilos de la misma
forma que las etiquetas HTML estándares. El siguiente ejemplo varios estilos aplicados a diferentes
controles de servidor. Si observamos el código fuente de la página devuelta al cliente, veremos que
estos estilos se pasan al navegador en la representación de los controles web que se mostraran según
el control determinado.
434 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

CREACIÓN DE LOS ESTILOS UTILIZANDO HOJAS DE ESTILOS

Hojas de Estilo - Una hoja de estilos en cascada (CSS) contiene reglas de estilo que se aplican a los
elementos de una página Web. Los estilos CSS definen la forma de mostrar los elementos y su posición
en la página. En lugar de asignar individualmente atributos a cada elemento de la página, puede crear
una regla general que aplique atributos específicos siempre que un explorador Web encuentre una
instancia de un elemento o un elemento asignado a una clase de estilo determinada.

Puede aplicar estilos CSS en línea a un elemento HTML individual, agrupados en un bloque style dentro
de la sección head de una página Web o importado desde un archivo de hoja de estilos en cascada
(CSS). Si se crean los estilos en una hoja de estilos en cascada, puede enlazar varias páginas Web a una
hoja de estilos, y así dar una apariencia uniforme a un sitio Web. Si está utilizando CSS para aplicar
estilos a los controles Web, debería utilizar la propiedad CssClass para definir un nombre de clase de
CSS que vaya asociada al control o a los elementos del control y después hacer referencia a ese nombre
de clase al asignar los estilos al control o a los elementos del control en la hoja de estilos.

Ahora para entender la idea bien, vamos a crear una hoja de estilos en la cual ingresaremos 3 tipos de
estilos que utilizaremos en un WebForms, el primer paso es crear una hoja de estilos la cual llevara por
nombre [Link]

Ahora digitaremos lo siguiente en la hoja de estilo recien creada

body
{ font-size: 8pt;
font-family:Tahoma, Verdana;
color:Blue; }
.texto
{ font-size: 8pt;
border-top-style : groove;
font-family:Tahoma,verdana;
border-right-style:groove;
border-left-style:groove;
border-bottom-style:groove;
color:Maroon; }
.titulo
{ font-size: 15pt;
font-family :Tahoma,Verdana;
color:#000066;
}
 Capítulo 13: Aprendiendo [Link] en 2010 435

Esta hoja de estilo, la vamos a aplicar a una página anteriormente creada

Vamos a modificar los siguientes detalles de su estructura. Para esto ingresemos a la parte de Source
de la Pagina y modifiquemos la parte del <Head> de la siguiente manera
<head runat=”server”>
<title>Pagina de Acceso</title>
<link rel=”stylesheet” type=”text/css” href=”[Link]” />
</head>

Esto hace que el cuerpo del programa (todo lo que se encuentra en el BODY) toma la característica
que le hemos dado en la hoja de estilo, luego podemos cambiar los estilos a los botones, para poder
realizar las modificaciones del caso.

<asp:Button ID=”Button1” runat=”server”

CssClass=”texto” Text=”Aceptar” style=”z-index: 108; left: 40px; position:
absolute; top: 224px” />

<asp:Button ID=”Button2” runat=”server”

CssClass=”texto” Text=”Cerrar” style=”z-index: 109; left: 136px; position:
absolute; top: 224px” />

CONTROLES DE VALIDACIÓN
Este grupo de controles nos permite validar la entrada dada por el usuario a traves de los controles de
un WebForm, esta validación se puede realizar en el cliente y en el servidor.

[Link], nos ofrece 6 controles de Validación

1. RequiredFieldValidator: Este control valida que se ha rellenado un campo con un valor, es decir
valida, los campos requeridos

2. CompareValidator: Este control lo utilizaremos para comparar el valor que contiene un control
WEB con un valor especifico, que puede ser un valor determinado como una constante o bien un
valor de otro control Web

Propiedades:
* ValueToCompare - Se utiliza cuando deseamos comparar el valor del control Web con un valor
constante, esta propiedad tendrá el valor constante
* ControlToCompare - cuando deseamos comparar el control WEB con otro control WEB
* Type - Indica el tipo de dato de los valores que se van a comparar, esta propiedad puede ser
Currency, Date, Double, Integer y String
436 Conociendo todo Visual Basic 2010, Net Framework 4.0 y [Link] 4.0

* Operator
Equal(igual) GreaterThan(Mayor)
GreaterThanEqual(mayor o Igual)
LessThan(Menor) LessThanEqual(menor o igual)
NotEqual(distinto) DataTypeCheck(Validacion Tipo)

3. RangeValidator: Este control se utilizara cuando deseamos comprobar si un valor de entrada de un

control Web se encuentra comprendido en un rango determinado
Propiedades:
* MinimunControl - Esta propiedad define el valor mínimo del rango permitido para el control
* MaximunControl - Esta propiedad define el valor máximo del rango permitido para el control
* Type - indica el tipo de dato que se utiliza para comparar los valores dentro de un rango
especificado, esta propiedad puede tener los siguientes valores: Currency, date, Double, Integer
y String.

4. RegularExpressionValidator: este control de validación es utilizado para comparar el valor del

control correspondiente con una expresión regular. Este control debe hacer uso de la propiedad
RegularExpressionValidator para indicar la expresión regular con la que se va a comparar el valor
indicado en el control Web.

5. CustomValidator: Se Utilizara para realizar Validaciones personalizadas, este control llamara a una
función definida por el usuario que será la que realice la validación.
Propiedades:
* ClientValidationFunction - indicaremos el nombre de la función del lado del cliente que realizara
la validación deseada, en este caso la función será desarrollada en un lenguaje Script
* OnServerValidate - Debemos indicar el nombre de la función del servidor que se va a encargar
de la validación correspondiente, esta función se ejecutara cuando se produzca el evento
ServerValidate.

6. ValidationSummary: Este control difiere del resto, ya que en realidad no va a realizar un tipo de
validación determinada, sino que contiene todos los mensajes de error que se han producido y
muestra una lista de ellos en la pagina(los cuales hallan fallado)
Propiedades:
* HeaderText - Contendrá el texto que va a mostrarse como cabecera a modo de descripcion de
errores
* ShowSummary - que puede tener los valores true o false,. Indicara si deseamos mostrar o no el
resumen de validación de la pagina
* DisplayMode - La forma en la que se va a mostrar las distintas descripciones de cada uno de
los errores de validación encontrados en la página, pueden ser : BulletList(una lista con puntos),
List(una LIsta) y SingleParagraph(un único párrafo)

Todos los Ejemplos de los controles de Validación, se encuentran en la Carpeta “Capítulo 13” de
las Aplicaciones del Libro de Visual Basic 2010.
DIRECCIONES DE INTERNET
Web Services
[Link]

Tutoriales de WebServices
[Link]
QuickStartv20/webservices/doc/[Link]&prev=/translate_s%3Fhl%3Des%26q%3D
manual%2Bde%2Bweb%2Bservices%2Bcon%[Link]%26tq%3Dmanual%2Bwith%2Basp.
net%2Bweb%2Bservices%26sl%3Des%26tl%3Den&usg=ALkJrhiD_1N9eBroOWrBnigIyrTU_GUGUg
[Link]

Video de controles de ASP. Net

[Link]

Base de datos en ASP

[Link]

Nuevo controles de [Link] 3.5

[Link]

Crear WebServices con SQL Server 2000

[Link]

Tutoriales de SDK
[Link]
net/&prev=/translate_s%3Fhl%3Des%26q%3Dmanual%2Bde%2Bweb%2Bservices%2Bcon%2Basp.
net%26tq%3Dmanual%2Bwith%[Link]%2Bweb%2Bservices%26sl%3Des%26tl%3Den

SqlDataSource
[Link]
[Link]

Ajax en tiempo Real

[Link]

Trabajando con [Link] 3.5

[Link]

Microsoft .NET Framework 3.5 Service Pack 1

[Link]
81DA479AB0D7&displaylang=en

Microsoft [Link] Dynamic Data

[Link]
Descarga Oficiales para [Link]
[Link]

Asp Ajax download

[Link]

Dynamic Data Wizard

[Link]

video - asp dinamyc data

[Link]

Dinamic data
[Link]
[Link], [Link] Dynamic Data, [Link] AJAX, [Link] MVC, Visual Studio, Silverlight/WPF
[Link]
dynamic-data-aspnet-ajax-aspnet-mvc-visual-studio-silverlightwpf/

Estilos
[Link]

Master Page
[Link]
[Link]
[Link]
[Link]
Impreso en los Talleres Gráficos de

Surquillo
7199700 – 7199701
 
Octubre 2011