Cursos De Programacion
alejandro910325 de Marzo de 2012
9.629 Palabras (39 Páginas)543 Visitas
Curso de iniciación a la programación con Visual Basic .NET
Guilermo Som “el Guille”
(Adaptación a Word, Marc Salvador. Rev A)
2
0.1. Introducción:................................................................................................................7
0.2. ¿Qué es el .NET Framework?.....................................................................................7
0.3. Sobre la versión de Visual Basic .NET:......................................................................8
0.4. Algunas aclaraciones preliminares:............................................................................8
1. Nuestra primera aplicación con Visual Basic .NET.: Primera entrega......................11
1.1. ¿Que es un Namespace (o espacio de nombres)?.....................................................13
1.2. ¿Que es un assembly (o ensamblado)?......................................................................14
2. Segunda entrega............................................................................................................17
3. Tercera entrega..............................................................................................................27
4. Cuarta entrega...............................................................................................................41
4.1. Variables, constantes y otros conceptos relacionados..............................................41
4.2. Tipos de datos de Visual Basic.NET y su equivalente en el Common Language Runtime (CLR)........................................................................................................................43
4.3. Sobre la necesidad u obligatoriedad de declarar las variables:...............................45
4.4. ¿Qué ventajas tiene usar constantes en lugar de usar el valor directamente?........48
4.5. Evaluar expresiones lógicas.......................................................................................51
5. Quinta entrega...............................................................................................................57
5.1. Declarar varias variables en una misma línea:........................................................57
5.2. Declarar varios tipos de variables en una misma línea:...........................................57
5.3. La visibilidad (o alcance) de las variables:...............................................................59
6. Sexta entrega..................................................................................................................63
6.1. Prioridad de los operadores.......................................................................................65
6.2. Bucles en Visual Basic .NET.....................................................................................66
7. Séptima entrega.............................................................................................................71
7.1. Las enumeraciones (Enum)..............................................................................72
8. Octava entrega...............................................................................................................81
8.2. Cómo hacer que se produzca una excepción:...........................................................87
9. Novena entrega..............................................................................................................91
9.1. Tipos de datos por valor.............................................................................................91
9.2. Tipos de datos por referencia.....................................................................................91
9.3. Los Arrays...................................................................................................................94
9.4. ¿Qué tipos de datos se pueden usar para crear arrays?...........................................94
9.5. Declarar variables como arrays.................................................................................95
9.6. Reservar memoria para un array...............................................................................95
9.7. Asignar valores a un array.........................................................................................96 3
9.8. Acceder a un elemento de un array..........................................................................96
9.9. Los límites de los índices de un array.......................................................................96
9.10. Saber el tamaño de un array.....................................................................................96
9.11. Inicializar un array al declararla..............................................................................97
9.12. Los arrays pueden ser de cualquier tipo...................................................................97
9.13. Usar un bucle For Each para recorrer los elementos de un array..........................97
9.14. Clasificar el contenido de un array...........................................................................98
9.15. El contenido de los arrays son tipos por referencia.................................................99
9.16. Copiar los elementos de un array en otro array.......................................................99
10. Décima entrega............................................................................................................101
10.1. Los arrays multidimensionales................................................................................101
10.2. Declarar arrays multidimensionales.......................................................................101
10.3. El tamaño de un array multidimensional...............................................................102
10.4. El número de dimensiones de un array multidimensional....................................102
10.6. Redimensionar un array multidimensional............................................................104
10.7. Eliminar un array de la memoria...........................................................................105
10.8. ¿Podemos clasificar un array multidimensional?..................................................105
10.9. Copiar un array multidimensional en otro.............................................................105
10.10. Los formatos a usar con las cadenas de Console.Write y WriteLine.................106
11. Undécima entrega.......................................................................................................111
11.1. La programación orientada a objetos.....................................................................111
11.2. Los tres pilares de la Programación Orientada a Objetos.....................................111
11.3. Las clases.................................................................................................................114
11.4. Los Objetos...............................................................................................................114
11.5. Los miembros de una clase......................................................................................114
11.6. Crear o definir una clase.........................................................................................115
11.7. Acceder a los miembros de una clase......................................................................116
11.8. Ejemplo de cómo usar la herencia..........................................................................117
12. Duodécima entrega.....................................................................................................121
12.1. Las partes o elementos de un proyecto de Visual Basic .NET...............................121
12.2. Las partes o elementos de una clase.......................................................................123
12.3. Los procedimientos: métodos de las clases.............................................................124
12.4. Parámetros o argumentos de los procedimientos...................................................125
12.5. Parámetros por valor y parámetros por referencia................................................126
13. Treceava entrega.........................................................................................................129
13.1. Parámetros opcionales.............................................................................................129 4
13.2. Sobrecarga de procedimientos.................................................................................131
13.3. Sobrecargar el constructor de las clases.................................................................133
13.4. Array de parámetros opcionales..............................................................................133
14. Glosario........................................................................................................................135 5
6
Curso de iniciación a la programación con Visual Basic .NET
(http://guille.costasol.net/NET/cursoVB.NET/tutorVBNET01.htm)
0.1. Introducción:
Debido a que la nueva versión de Visual Basic no es sólo una mejora con respecto a las versiones anteriores, sino que cambia mucho, tanto como si de otro lenguaje de programación se tratara, creo que se merece
...