APRENDA PRACTICANDO VISUAL BASIC USANDO VISUAL STUDIO 2012

El libro abarca todos los elementos esenciales del lenguaje Visual Basic y cubre a detalle las herramientas gráficas contenidas en Visual Studio 2012 para el desarrollo asistido de aplicaciones. Domine las estructuras básicas del lenguaje, la programación orientada a objetos y el desarrollo de aplicaciones multicapa con Windows Applications y SQL Server. Cubrir los temas de esté libro contribuye a la preparación de la certificación APCP: Microsoft .NET Developer.

Ventajas Competitivas:

• Desde la Web se puede descargar material complementario: 30 ejercicios resueltos, 1 demostración y 55 videos explicativos.
• Explicación detallada del uso de Visual Studio 2012 para el desarrollo de programas, clases, interfaces gráficas y Stored Procedures en SQL Server. Ejercicios paso a paso, con videos de soporte que muestran visualmente la secuencia de acciones.
• Único libro que muestra, de forma concisa y efectiva la implementación de aplicaciones Visual Basic con acceso a datos en SQL Server, en esquema multicapa.

Conozca:

• La estructura de la plataforma Microsoft NET (CLR, BCL, Assemblies, NET Languages) los fundamentos del lenguaje Visual Basic (estructuras, variables, arreglos, procedimientos, funciones, iteradores, threads), los elementos de la programación orientada a objetos (clases, herencia y polimorfismo), diseño de interfaces gráficas con Windows Applications (Controles, Event-Driving Apps, Data Validation), ADO.NET para el acceso a bases de datos (DataSet y Data Providers Objects), y desarrollo de aplicaciones multicapa (Stored Procedures, Libraries, GUI/Windows Applications).

Implemente:

• Aplicaciones Windows que consulten, modifiquen y eliminen registros de bases de datos SQL Server.
• Diferentes tipos de proyectos: Console Applications, Class Library, Windows Applications, y Data Sources.

Domine:

El uso de las ventanas de herramientas de Visual Studio 2012 para la administración de soluciones y proyectos (Solution Explorer), codificación asistida (Code Editor, Intellisense, Code Snippets), diseño de interfaces (Windows Form Designer), creación y modificación de clases (Class Designer y Class Diagram), manipulación de propiedades (Properties Windows), depuración y seguimiento de ejecución de aplicaciones (Output Window, Intellitrace, Task Window, Watch), administración de conexiones a fuentes de datos (Server Explorer), así como el manejo de archivos de configuración (XML Editor).

Acerca del autor …………………………………………………………………………………………………………………………..
Dedicatoria ……………………………………………………………………………………………………………………………………
xv
Contexto del curso ……………………………………………………………………………………………………………………….
xv ii
Requerimientos del curso ………………………………………………………………………………………………………….
xviii
Descripción de las unidades ………………………………………………………………………………………………………
Resumen de Unidades…………………………………………………………………………………………………………………
xix
Cómo utilizar el libro …………………………………………………………………………………………………………………..
xxi
1.1 Definiendo a la plataforma .NET ………………………………………………………………………………………………… 3
1.1.1 ¿Qué es Microsoft .NET?………………………………………………………………………………………………………..3
1.1.2 Historia de versiones de .NET………………………………………………………………………………………………3
1.1.3 Instalaciones de .NET…………………………………………………………………………………………………………….4
1.1.4 ¿Cómo funciona .NET? …………………………………………………………………………………………………………..5
1.1.5 Principales capas de Microsoft . NET Framework ……………………………………………………………6
1.2 Entendiendo a los lenguajes .NET ……………………………………………………………………………………………… 9
1.2.1 ¿Qué es un lenguaje .NET?…………………………………………………………………………………………………….9
1.2.3 Capacidad multilenguaje de .NET………………………………………………………………………………………..9
1.3 Determinando la plataforma .NET requerida ……………………………………………………………………….. 11
 Lab.01.01: Exponiendo Microsoft .NET como producto. ………………………………………………………. 13
 Lab.01.02: Determinando la plataforma .NET para desarrollo. …………………………………………… 14

2.1 Organización del trabajo en Visual Studio ……………………………………………………………………………..19
2.1.1 Soluciones, proyectos, elementos ……………………………………………………………………………………..19
2.1.2 ¿Dónde almacena Visual Studio el trabajo? ……………………………………………………………………20
2.1.3 Tipos de proyecto disponibles en Visual Studio ……………………………………………………………21
2.1.4 Proceso de construcción (Build) ……………………………………………………………………………………….22
2.2 Herramientas en Visual Studio …………………………………………………………………………………………………24
2.2.1 Diseñadores ………………………………………………………………………………………………………………………….25
2.2.2 Ventanas ………………………………………………………………………………………………………………………………..26
2.2.3 Editores ………………………………………………………………………………………………………………………………….27
2.3 Un adelanto: Sintaxis en Visual Basic ………………………………………………………………………………………28
 Lab.02.01: Manejando soluciones y proyectos ………………………………………………………………………..29
a) Creando una solución en blanco………………………………………………………………………………………….29
b) Agregando proyectos a una solución………………………………………………………………………………….31
c) Trabajando con varios proyectos en una solución…………………………………………………………….32
d) Comprobando Auto-Hide………………………………………………………………………………………………………34
e) Agregando y eliminando elementos de proyecto ………………………………………………………………34
f) Guardando el trabajo …………………………………………………………………………………………………………….35
 Lab.02.02: Manejo de Code Editor …………………………………………………………………………………………….35
a) Creando una aplicación de Consola…………………………………………………………………………………….35
b) Utilizando herramientas de Code Editor ……………………………………………………………………………37
c) Depurando aplicaciones ……………………………………………………………………………………………………….38
 Lab.02.03: Creando una solución, un proyecto y un programa. …………………………………………..40
3.1 ¡Qué son las Variables de memoria? ………………………………………………………………………………………..43
3.2 Identificadores (Identifiers) ……………………………………………………………………………………………………..43
3.3 Tipos de dato (Datatypes) …………………………………………………………………………………………………………44
3.3.1Conversión de datos …………………………………………………………………………………………………………….46
3.3.2 Conversión implícita (Casting) ………………………………………………………………………………………….46
3.3.3 Conversión explícita ……………………………………………………………………………………………………………46
3.3.4 Conversión por método ………………………………………………………………………………………………………47
3.4 Manejo elemental de variables …………………………………………………………………………………………………47

3.4.1 Declaración de variables ……………………………………………………………………………………………………. 47
3.4.2 Constantes ……………………………………………………………………………………………………………………………. 49
3.4.3 Literales ………………………………………………………………………………………………………………………………… 49
3.4.4 Valores por omisión ……………………………………………………………………………………………………………. 50
3.5 Alcance de las variables (Scope) ……………………………………………………………………………………………… 50
3.6 Accesibilidad de las variables (Accesibility) …………………………………………………………………………. 51
3.7 Arreglos ……………………………………………………………………………………………………………………………………….. 53
3.7.1 Arreglos unidimensionales ……………………………………………………………………………………………….. 54
3.7.2 Arreglos multidimensionales ……………………………………………………………………………………………. 55
3.7.3 Arreglos escalonados …………………………………………………………………………………………………………. 57
3.8 Dando formato con String.Format ………………………………………………………………………………………….. 58
 Lab.03.01: Variables, constantes y conversiones. ………………………………………………………………….. 60
 Lab.03.02: Comprobación de alcance ………………………………………………………………………………………. 62
 Lab.03.03: Arreglos unidimensionales, multidimensionales y escalonados. ……………………. 66
 Lab.03.04: Creando programa strong typing con manejo de arreglos. ……………………………… 71
 Lab.03.05: Especificando el alcance y la accesibilidad adecuadas. …………………………………….. 72
4.1. Espacios de nombres (Namespaces) ……………………………………………………………………………………… 77
4.1.1 Sistema de nomenclatura para los espacios de nombres ……………………………………………. 78
4.1.2 Uso de espacios de nombres …………………………………………………………………………………………….. 79
4.1.3 Creación de espacios de nombres ……………………………………………………………………………………. 80
4.1.4 Estableciendo alias para los espacios de nombres ……………………………………………………….. 81
4.1.5 Estableciendo referencias a una librería ………………………………………………………………………… 82
 Lab.04.01: Creación y consumo de una librería (DLL) basada en Namespace …………………. 83
a) Creando una librería DLL ……………………………………………………………………………………………………. 84
b) Estableciendo una referencia a una librería desde Solution Explorer ………………………….. 85
c) Consumiendo una librería programáticamente……………………………………………………………….. 86
 Lab.04.02: Tareas de depuración con Visual Studio ……………………………………………………………… 87
a) Estableciendo un punto de interrupción (breakpoint)……………………………………………………. 88
b) Ejecución línea por línea (Code Stepping)………………………………………………………………………… 88
c) Modificación de programas en tiempo de ejecución………………………………………………………… 91
d) Habilitando e inhabilitando puntos de interrupción……………………………………………………….. 91
e) Eliminando los puntos de interrupción (breakpoint)………………………………………………………. 91
f) Puntos de interrupción condicionales…………………………………………………………………………………. 92

 Lab.04.03: Inspección de código y variables ……………………………………………………………………………93
a) Locals Window……………………………………………………………………………………………………………………….94
b) Call Stack Window………………………………………………………………………………………………………………… 95
c) Watch Window……………………………………………………………………………………………………………………….95
c) IntelliTrace ……………………………………………………………………………………………………………………………..96
 Lab.04.04: Creando y depurando librerías ………………………………………………………………………………97
a) Creando Namespace ……………………………………………………………………………………………………………..98
b) Creando aplicación que consume Namespace …………………………………………………………………..99
c) Usando herramientas de depuración de Visual Studio……………………………………………………..99
5.1 Operadores aritméticos ……………………………………………………………………………………………………………103
5.2 Operadores de asignación ……………………………………………………………………………………………………….104
5.2.1 Expresión …………………………………………………………………………………………………………………………….104
5.2.2 Operadores de asignación incluyente …………………………………………………………………………….105
5.3 Operadores comparativos ……………………………………………………………………………………………………….106
5.3.1 Consideraciones relativas al código ASCII …………………………………………………………………….107
5.3.2 Option Compare …………………………………………………………………………………………………………………108
5.3.3 Operadores Is, IsNot y TypeOf …………………………………………………………………………………………109
5.3.4 Operador Like …………………………………………………………………………………………………………………….110
5.4 Operadores lógicos ……………………………………………………………………………………………………………………111
5.4.1 Operadores lógicos de circuito corto ……………………………………………………………………………..114
5.5 Prioridad entre operadores …………………………………………………………………………………………………….115
5.5.1 Uso de paréntesis para otorgar preferencia de ejecución ………………………………………….117
 Lab.05.01: Utilización general de operadores de Visual Basic ……………………………………………117
a) Comentando bloques de código …………………………………………………………………………………………119
b) Uso de Clipboard Ring …………………………………………………………………………………………………………119
c) Selección basada en bloques de código (Block Selection)………………………………………………120
 Lab.05.02: Representando con operadores casos de la vida real. ……………………………………..121
6.1 Estructuras de decisión …………………………………………………………………………………………………………..127

6.1.1 Estatuto If Then Else (condicional) ……………………………………………………………………………….127
6.1.2 Select Case ………………………………………………………………………………………………………………………….129
6.2 Estructuras de control …………………………………………………………………………………………………………….130
6.2.1 For Next ………………………………………………………………………………………………………………………………131
6.2.2 While ……………………………………………………………………………………………………………………………………132
6.2.3 Do Loop ……………………………………………………………………………………………………………………………….133
6.3 Estructuras envolventes y anidadas ……………………………………………………………………………………. 135
6.3.1 Reglas para el anidado de estructuras ………………………………………………………………………….135
 Lab.06.01: Uso de estructuras de decisión ……………………………………………………………………………136
 Lab.06.02: Uso de For Next ………………………………………………………………………………………………………139
a) Agregando tareas a Task List……………………………………………………………………………………………143
b) Agregando comentarios de tarea a un programa………………………………………………………….144
 Lab.06.03: Identificando errores en estructuras anidadas ………………………………………………..145
 Lab.06.04: Decidiendo el uso de estructuras de decisión y de control. …………………………… 146
7.1 Errores versus Excepciones ……………………………………………………………………………………………………151
7.2 Manejo estructurado de excepciones ……………………………………………………………………………………151
7.3 Try…Catch…Finally ……………………………………………………………………………………………………………………152
7.3.1 Bloque Try …………………………………………………………………………………………………………………………..152
7.3.2 Bloque Catch ……………………………………………………………………………………………………………………….152
7.3.3 Bloque Finally …………………………………………………………………………………………………………………….153
7.3.4 Clase System.Exception …………………………………………………………………………………………………….153
7.4 Filtrado de excepciones……………………………………………………………………………………………………………155
7.4.1 Calificadores de excepción ……………………………………………………………………………………………….155
7.4.2 Objeto Err ……………………………………………………………………………………………………………………………155
7.4.3 Tipos de filtrado de excepciones ……………………………………………………………………………………. 156
7.5 Lanzando nuestras propias excepciones ………………………………………………………………………………156
 Lab.07.01: Manejo estructurado de excepciones ………………………………………………………………….156
a) Manejo preventivo de excepciones usando Error List…………………………………………………….159
b) Actualizaciones preventivas en cascada…………………………………………………………………………..161
 Lab.07.02: Filtrado de excepciones …………………………………………………………………………………………161
 Lab.07.03: Lanzamiento de excepciones definidas por el usuario …………………………………….165
 Lab.07.04: Proporcionando manejo estructurado de excepciones a los programas. …….167

8.1 Procedimientos ………………………………………………………………………………………………………………………….171
8.1.1 ¿Cuándo definir procedimientos y funciones? ……………………………………………………………..171
8.1.2 Forma de agregar procedimientos a un programa ………………………………………………………172
8.1.3 Forma de mandar llamar a ejecución un procedimiento ……………………………………………173
8.1.4 Argumentos …………………………………………………………………………………………………………………………173
8.1.4.1 Especificación ByVal ……………………………………………………………………………………………………173
8.1.4.2 Especificación ByRef…………………………………………………………………………………………………….174
8.1.5 Valores de retorno ……………………………………………………………………………………………………………..174
8.2 Codificación de procedimientos y funciones ……………………………………………………………………….174
8.2.1 Procedimientos …………………………………………………………………………………………………………………..174
8.2.2 Funciones …………………………………………………………………………………………………………………………….175
 Lab.08.01: Procedimiento que no utiliza argumentos …………………………………………………………177
 Lab.08.02: Procedimiento que declara argumentos pero no retorna valores …………………179
 Lab.08.03: Procedimiento que declara argumentos y retorna valores……………………………..182
 Lab.08.04: Uso de ByVal y ByRef ……………………………………………………………………………………………..185
 Lab.08.05: Procedimientos multihilos y procesamiento asíncrono. ………………………………….187
 Lab.08.06: Decidiendo el uso de procedimientos y funciones. …………………………………………..191
9.1 Términos básicos de POO ………………………………………………………………………………………………………..197
9.1.1 Clases y objetos …………………………………………………………………………………………………………………..197
9.1.2 Campos, propiedades, métodos y eventos …………………………………………………………………….197
9.1.3 Encapsulamiento, herencia y polimorfismo ………………………………………………………………….198
9.1.3.1 Encapsulamiento………………………………………………………………………………………………………….199
9.1.3.2 Herencia ………………………………………………………………………………………………………………………..199
9.1.3.3 Polimorfismo…………………………………………………………………………………………………………………200
9.2 Elementos esenciales de los objetos ……………………………………………………………………………………..200
9.2.1 Identidad ……………………………………………………………………………………………………………………………..200
9.2.2 Estado …………………………………………………………………………………………………………………………………..201
9.2.3 Comportamiento ………………………………………………………………………………………………………………..201
9.3 Clases, Métodos y Propiedades ………………………………………………………………………………………………202
9.3.1 Definición de una clase ……………………………………………………………………………………………………..202

9.3.2 Definición de propiedades ……………………………………………………………………………………………….203
9.3.3 Modificadores de Acceso ………………………………………………………………………………………………….205
 Lab.09.01: Creando una clase con propiedades y métodos ………………………………………………..206
a) Uso de Code Snippets…………………………………………………………………………………………………………..206
b) Class Diagram………………………………………………………………………………………………………………………209
c) Class View ……………………………………………………………………………………………………………………………..212
d) Selector de documentos activos (Active Documents)……………………………………………………..212
e) Agregando resumen a los miembros…………………………………………………………………………………213
f) Consumiendo la clase …………………………………………………………………………………………………………..215
 Lab.09.02: Haciendo un programa class-based …………………………………………………………………….216
10.1 Herencia y Polimorfismo ………………………………………………………………………………………………………221
10.1.1 Herencia …………………………………………………………………………………………………………………………….221
10.1.2 ¿Cuándo se debe utilizar la herencia? ………………………………………………………………………….221
10.1.3 Overloading, Overriding, y Shadowing ………………………………………………………………………..222
10.1.3.1 Overloaded………………………………………………………………………………………………………………….222
10.1.3.2 Overriden…………………………………………………………………………………………………………………….222
10.1.3.3 Shadowed……………………………………………………………………………………………………………………223
10.1.4 Formas de herencia …………………………………………………………………………………………………………223
10.1.4.1 Inherits (Heredar)……………………………………………………………………………………………………..223
10.1.4.2 NotInheritable (No Heredable)………………………………………………………………………………..223
10.1.4.3 MustInherit (Debe Heredar)……………………………………………………………………………………. 224
10.2 Polimorfismo …………………………………………………………………………………………………………………………..224
10.2.1 Estatutos auxiliares de polimorfismo ………………………………………………………………………….225
10.2.1.1 NotOverridable (No Remplazable)………………………………………………………………………….226
10.2.1.2 Overridable (Remplazable)………………………………………………………………………………………226
10.2.1.3 MustOverride (Debe Remplazarse)…………………………………………………………………………226
10.2.1.4 Overrides (Remplaza)……………………………………………………………………………………………….227
10.2.1.5 Overloads (Sobrecarga/Sustituye)………………………………………………………………………….227
10.2.2 MyBase y MyClass ……………………………………………………………………………………………………………227
 Lab.10.01: Herencia entre clases ……………………………………………………………………………………………..228
 Lab.10.02: Polimorfismo basado en herencia ……………………………………………………………………….230
a) Clase base ……………………………………………………………………………………………………………………………..232
b) Clase derivada con remplazamiento…………………………………………………………………………………233

c) Clase derivada con sustitución……………………………………………………………………………………………236
 Lab.10.03: Iteradores …………………………………………………………………………………………………………………239
 Lab.10.04: Implementación de herencia y polimorfismo ……………………………………………………243
11.1 Interfaz de usuario ………………………………………………………………………………………………………………… 247
11.2 Controles ………………………………………………………………………………………………………………………………….248
11.2.1 Toolbox………………………………………………………………………………………………………………………………248
11.2.2 Formas de agregar controles a una interfaz ……………………………………………………………….249
11.2.3 ¿Cómo aprender a usar los Controles?…………………………………………………………………………249
11.2.3.1 Piense en términos de clases……………………………………………………………………………………. 249
11.2.3.2 Piense en su necesidad ………………………………………………………………………………………………249
11.2.3.3 Propósito de la clase ………………………………………………………………………………………………….250
11.2.3.4 Conozca los miembros de una clase ………………………………………………………………………..250
11.2.4 Relación de controles………………………………………………………………………………………………………252
11.2.4.1 De estructura ……………………………………………………………………………………………………………..252
11.2.4.2 Para introducción y especificación de datos………………………………………………………….253
11.2.4.3 Para definir layout…………………………………………………………………………………………………….255
11.2.4.4 Para desencadenar acciones……………………………………………………………………………………. 257
11.2.4.5 Para manipulación de datos……………………………………………………………………………………. 258
11.3 Desarrollo de interfaces basadas en objetos ……………………………………………………………………..258
11.3.1 Entendiendo el propósito de la interfaz ………………………………………………………………………258
11.3.2 Determinación de datos involucrados …………………………………………………………………………259
11.3.4 Determinación de objetos recomendados …………………………………………………………………..259
11.3.5 Validaciones ……………………………………………………………………………………………………………………..261
 Lab.11.01: Uso de ayuda msdn y .NET Framework ………………………………………………………………262
a) Ingresando a MSDN …………………………………………………………………………………………………………….262
b) Buscando información de clases………………………………………………………………………………………..263
 Lab.11.02: Investigando clases básicas …………………………………………………………………………………..266
a) Label………………………………………………………………………………………………………………………………………266
b) TextBox………………………………………………………………………………………………………………………………….266
c) MaskedTextBox…………………………………………………………………………………………………………………….267
d) Button……………………………………………………………………………………………………………………………………267
 Lab.11.03: Creando una interfaz con Windows Applications ……………………………………………..267

a) Seleccionando los controles adecuados ……………………………………………………………………………269
b) Agregando objetos a la interfaz ………………………………………………………………………………………..269
c) Estableciendo el orden de tabulación (TabOrder) ………………………………………………………….270
d) Estableciendo propiedades a los objetos………………………………………………………………………….270
e) Programando comportamientos……………………………………………………………………………………….273
 Lab.11.04: Creando su propia interfaz ……………………………………………………………………………………276
12.1 Modelo de objetos de ADO.NET ………………………………………………………………………………………….279
12.1.1 Data Provider Objects …………………………………………………………………………………………………..279
12.1.2 DataSet Objects ………………………………………………………………………………………………………………281
12.2 Enfoques de enlace a datos …………………………………………………………………………………………………283
12.2.1 Bases de datos conectadas …………………………………………………………………………………………..283
12.2.2 Bases de datos desconectadas ……………………………………………………………………………………. 285
12.3 Espacios de nombres relacionados con ADO.NET ………………………………………………………….286
12.4 Conexiones a bases de datos específicas ………………………………………………………………………….287
12.4.1 Conexión basada en Access ………………………………………………………………………………………….287
12.4.2 Conexión basada en SQL Server 7.0 o superior ……………………………………………………….. 288
12.4.3 Conexión basada en Oracle ………………………………………………………………………………………….288
12.5 Enlazado de datos (Data Binding) ……………………………………………………………………………………..289
12.5.1 Enlazado simple ……………………………………………………………………………………………………………..289
12.5.2 Enlazado complejo ………………………………………………………………………………………………………..289
 Demo.12.01: La base de datos Pubs ………………………………………………………………………………………290
 Lab.12.01: Conexión a bases de datos con Visual Studio …………………………………………………..292
a) Información preliminar de la base de datos…………………………………………………………………..292
b) Creando una conexión en Visual Studio ………………………………………………………………………….292
c) Creando un DataSet para consumo de datos………………………………………………………………….293
d) Definiendo BindingSource e interfaz de datos con TableAdapter ………………………………295
e) Enlazado complejo con BindingSource y BindingNavigator………………………………………..296
f) Enlazado simple con TextBox ……………………………………………………………………………………………297
 Lab.12.02: Conexión a bases de datos por programa …………………………………………………………298
a) Habilitando el acceso a los archivos de configuración …………………………………………………299
b) Obteniendo información de App.config…………………………………………………………………………..300
c) Conectando a la base de datos de forma programática ……………………………………………….300
d) Código de conexión simplificado………………………………………………………………………………………301
 Lab.12.03 Listas desplegables dependientes, en modo desconectado …………………………… 302
 Lab.12.04 Visor de registros ……………………………………………………………………………………………………306

13.1 Modelo de desarrollo Multicapa ……………………………………………………………………………………….. 309
13.1.1 Capa de presentación (Presentation Tier) ………………………………………………………………. 309
13.1.2 Capa de procesamiento (Processing Tier) ………………………………………………………………. 310
13.1.3 Capa de datos (Data Tier) …………………………………………………………………………………………… 311
13.2 Implementación de Multicapa con Windows Applications y SQL Server …………………. 311
13.2.1 Secuencia de implementación ……………………………………………………………………………………. 311
13.2.2 Conocimientos requeridos …………………………………………………………………………………………. 312
13.3 Objeto Command …………………………………………………………………………………………………………………. 313
13.3.1 Tipos de comandos ………………………………………………………………………………………………………. 314
13.3.2 Tipos de ejecución de los comandos …………………………………………………………………………. 315
 Lab.13.01: Desarrollando la capa de datos …………………………………………………………………………. 315
a) Conocimiento de la base ………………………………………………………………………………………………….. 315
b) Conocimiento de la tabla a manipular ………………………………………………………………………….. 316
c) Creando stored procedures en SQL Server usando Server Explorer ………………………….. 317
d) Probando stored procedures desde Visual Studio………………………………………………………… 319
e) Realizando consultas desde Visual Studio …………………………………………………………………….. 323
 Lab.13.02: Desarrollando la capa de procesamiento ………………………………………………………… 325
a) Creación de una clase ………………………………………………………………………………………………………. 325
b) Agregando propiedades usando Code Snippets……………………………………………………………. 326
c) Agregando métodos que usan Command y DataReader……………………………………………… 329
d) Agregando métodos que usan Command con ExecuteScalar …………………………………….. 331
 Lab.13.03 Desarrollando la capa de presentación …………………………………………………………….. 332
a) Agregando proyectos existentes a una solución…………………………………………………………… 333
b) Agregando imágenes y barras de status……………………………………………………………………….. 334
c) Referenciando la clase de capa de procesamiento……………………………………………………….. 336
d) Instanciando la clase de capa de procesamiento…………………………………………………………. 337
e) Recuperando la cadena de conexión de App.config……………………………………………………… 338
f) Buscando información en la base de datos……………………………………………………………………. 339
g) Agregando y modificando información en la base de datos……………………………………….. 340
h) Eliminando información en la base de datos ……………………………………………………………….. 341
 Lab.13.04 Realizando su propia aplicación ………………………………………………………………………… 342