Locura, Informatica, Musica y Oscuridad

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

Function CONVIERTENUMLETRA(NUMERO)
Dim TEXTO
Dim MILLONES
Dim MILES
Dim CIENTOS
Dim DECIMALES
Dim CADENA
Dim CADMILLONES
Dim CADMILES
Dim CADCIENTOS
TEXTO = NUMERO
TEXTO = FormatNumber(TEXTO, 2)
TEXTO = Right(Space(14) & TEXTO, 14)
MILLONES = Mid(TEXTO, 1, 3)
MILES = Mid(TEXTO, 5, 3)
CIENTOS = Mid(TEXTO, 9, 3)
DECIMALES = Mid(TEXTO, 13, 2)
CADMILLONES = CONVIERTECIFRA(MILLONES, 1)
CADMILES = CONVIERTECIFRA(MILES, 1)
CADCIENTOS = CONVIERTECIFRA(CIENTOS, 0)
If Trim(CADMILLONES) > "" Then
If Trim(CADMILLONES) = "UN" Then
CADENA = CADMILLONES & " MILLON"
Else
CADENA = CADMILLONES & " MILLONES"
End If
End If
If Trim(CADMILES) > "" Then
CADENA = CADENA & " " & CADMILES & " MIL"
End If


If Trim(CADMILES & CADCIENTOS) = "UN" Then
CADENA = CADENA & "UNO PESOS" & DECIMALES & "/100" & " M.N. "
Else
If MILES & CIENTOS = "000000" Then
CADENA = CADENA & " " & Trim(CADCIENTOS) & " PESOS " & DECIMALES & "/100" & " M.N. "
Else
CADENA = CADENA & " " & Trim(CADCIENTOS) & " PESOS " & DECIMALES & "/100" & " M.N. "
End If
End If
CONVIERTENUMLETRA = Trim(CADENA)
End Function

Function CONVIERTECIFRA(TEXTO, SW)
Dim CENTENA
Dim DECENA
Dim UNIDAD
Dim TXTCENTENA
Dim TXTDECENA
Dim TXTUNIDAD
CENTENA = Mid(TEXTO, 1, 1)
DECENA = Mid(TEXTO, 2, 1)
UNIDAD = Mid(TEXTO, 3, 1)
Select Case CENTENA
Case "1"
TXTCENTENA = "CIEN"
If DECENA & UNIDAD <> "00" Then
TXTCENTENA = "CIENTO"
End If
Case "2"
TXTCENTENA = "DOSCIENTOS"
Case "3"
TXTCENTENA = "TRESCIENTOS"
Case "4"
TXTCENTENA = "CUATROCIENTOS"
Case "5"
TXTCENTENA = "QUINIENTOS"
Case "6"
TXTCENTENA = "SEISCIENTOS"
Case "7"
TXTCENTENA = "SETECIENTOS"
Case "8"
TXTCENTENA = "OCHOCIENTOS"
Case "9"
TXTCENTENA = "NOVECIENTOS"
End Select

Select Case DECENA
Case "1"
TXTDECENA = "DIEZ"
Select Case UNIDAD
Case "1"
TXTDECENA = "ONCE"
Case "2"
TXTDECENA = "DOCE"
Case "3"
TXTDECENA = "TRECE"
Case "4"
TXTDECENA = "CATORCE"
Case "5"
TXTDECENA = "QUINCE"
Case "6"
TXTDECENA = "DIECISEIS"
Case "7"
TXTDECENA = "DIECISIETE"
Case "8"
TXTDECENA = "DIECIOCHO"
Case "9"
TXTDECENA = "DIECINUEVE"
End Select
Case "2"
TXTDECENA = "VEINTE"
If UNIDAD <> "0" Then
TXTDECENA = "VEINTI"
End If
Case "3"
TXTDECENA = "TREINTA"
If UNIDAD <> "0" Then
TXTDECENA = "TREINTA Y "
End If
Case "4"
TXTDECENA = "CUARENTA"
If UNIDAD <> "0" Then
TXTDECENA = "CUARENTA Y "
End If
Case "5"
TXTDECENA = "CINCUENTA"
If UNIDAD <> "0" Then
TXTDECENA = "CINCUENTA Y "
End If
Case "6"
TXTDECENA = "SESENTA"

If UNIDAD <> "0" Then
TXTDECENA = "SESENTA Y "
End If
Case "7"
TXTDECENA = "SETENTA"
If UNIDAD <> "0" Then
TXTDECENA = "SETENTA Y "
End If
Case "8"
TXTDECENA = "OCHENTA"
If UNIDAD <> "0" Then
TXTDECENA = "OCHENTA Y "
End If
Case "9"
TXTDECENA = "NOVENTA"
If UNIDAD <> "0" Then
TXTDECENA = "NOVENTA Y "
End If
End Select

If DECENA <> "1" Then
Select Case UNIDAD
Case "1"
If SW Then
TXTUNIDAD = "UN"
Else
TXTUNIDAD = "UNO"
End If
Case "2"
TXTUNIDAD = "DOS"
Case "3"
TXTUNIDAD = "TRES"
Case "4"
TXTUNIDAD = "CUATRO"
Case "5"
TXTUNIDAD = "CINCO"
Case "6"
TXTUNIDAD = "SEIS"
Case "7"
TXTUNIDAD = "SIETE"
Case "8"
TXTUNIDAD = "OCHO"
Case "9"
TXTUNIDAD = "NUEVE"
End Select
End If
CONVIERTECIFRA = TXTCENTENA & " " & TXTDECENA & TXTUNIDAD
End Function


codigo visual basic 6, para agregar en modulo de excel o acces que convierte un numero en letras