• Bienvenido

    Este es un espacion donde conjugare la locura (escribire letras con mi podredumbre interior), metere el sofware que use y me sea de utilidad, pondre libros que ame, y musica que me reviente las entrañas.



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
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
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 ........................................................................................................................ 135http://www.blogger.com/img/blank.gif

genial curso para todos aquellos que inician en .net, habre de decir que yo aprendi visual basic con el curso anterior del guille, asi k se k sus ejemplos son muy claros, y su modo de explicar sencillo, con unos toques de humor, pero sobrehttp://www.blogger.com/img/blank.gif todo con calidad, en este pdf, viene hasta la entrega 13, pero en la web del autor podras encontrar las ultimas entregas.

gracias al guille, por su tiempo y dedicacion, pero sobre todo por ese deseo de dar conocimiento sin costo alguno.

link del pdf



la web del autor





0 Response for the "iniciacion a la programacion en visual basic.net"

Publicar un comentario