PRÓLOGO.................................................................................................... XIII
CAPÍTULO 1. FASES EN EL DESARROLLO DE UN PROGRAMA....... 1
QUÉ ES UN PROGRAMA......................................................................... 1
QUÉ ES C#................................................................................................ 2
REALIZACIÓN DE UN PROGRAMA EN C#........................................... 3
Cómo crear un programa......................................................................... 4
Interfaz de línea de órdenes..................................................................... 4
¿Qué hace este programa?.................................................................. 5
Guardar el programa escrito en el disco................................................ 6
Compilar y ejecutar el programa.......................................................... 6
Biblioteca de clases............................................................................ 8
Guardar el programa ejecutable en el disco........................................... 9
Depurar un programa.......................................................................... 10
Entorno de desarrollo integrado................................................................ 10
EJERCICIOS RESUELTOS........................................................................ 13
EJERCICIOS PROPUESTOS..................................................................... 14
CAPÍTULO 2. FUNDAMENTOS DE C#..................................................... 15
DECLARACIÓN DE UNA VARIABLE..................................................... 15
ASIGNAR VALORES................................................................................ 18
AÑADIR COMENTARIOS........................................................................ 20
MOSTRAR DATOS POR LA PANTALLA................................................ 21
EXPRESIONES ARITMÉTICAS................................................................ 22
EXPRESIONES CONDICIONALES........................................................... 23
ESCRIBIR NUESTROS PROPIOS MÉTODOS.......................................... 25
EJERCICIOS PROPUESTOS..................................................................... 27
CAPÍTULO 3. PROGRAMACIÓN ORIENTADA A OBJETOS............... 29
PENSAR EN OBJETOS............................................................................. 30
Clases y objetos...................................................................................... 30
Mensajes y métodos................................................................................ 31
DISEÑO DE UNA CLASE DE OBJETOS.................................................. 32
CONSTRUCTORES................................................................................... 39
HERENCIA................................................................................................ 42
EJERCICIOS RESUELTOS........................................................................ 49
EJERCICIOS PROPUESTOS..................................................................... 55
CAPÍTULO 4. ELEMENTOS DEL LENGUAJE........................................ 57
CARACTERES DE C#............................................................................... 57
TIPOS........................................................................................................ 59
LITERALES............................................................................................... 60
Literales enteros...................................................................................... 60
Literales reales........................................................................................ 61
Literales de un solo carácter.................................................................... 62
Literales de cadenas de caracteres........................................................... 62
IDENTIFICADORES.................................................................................. 63
PALABRAS CLAVE.................................................................................. 63
DECLARACIÓN DE CONSTANTES SIMBÓLICAS................................. 64
¿Por qué utilizar constantes?.................................................................... 65
VARIABLES.............................................................................................. 65
CONVERSIÓN ENTRE TIPOS PRIMITIVOS............................................ 67
OPERADORES.......................................................................................... 68
Operadores lógicos.................................................................................. 68
Operadores unitarios................................................................................ 69
Operadores a nivel de bits........................................................................ 69
Operadores de asignación........................................................................ 70
Operador condicional............................................................................... 72
PRIORIDAD Y ORDEN DE EVALUACIÓN............................................. 73
EJERCICIOS RESUELTOS........................................................................ 74
EJERCICIOS PROPUESTOS..................................................................... 76
CAPÍTULO 5. ESTRUCTURA DE UN PROGRAMA................................ 77
ESTRUCTURA DE UN PROGRAMA C#.................................................. 77
Espacios de nombres............................................................................... 81
Protección de una clase........................................................................... 83
Directriz using......................................................................................... 84
Definiciones y declaraciones.................................................................... 85
Sentencia simple...................................................................................... 86
Sentencia compuesta o bloque.................................................................. 86
Métodos................................................................................................. 86
Definición de un método...................................................................... 87
Método Main.......................................................................................... 88
Crear objetos de una clase....................................................................... 88
Cómo acceder a los miembros de un objeto............................................... 89
Protección de los miembros de una clase.................................................. 90
Miembro de un objeto o de una clase........................................................ 92
Referencias a objetos.............................................................................. 94
Pasando argumentos a los métodos........................................................... 97
EJERCICIOS RESUELTOS........................................................................ 98
EJERCICIOS PROPUESTOS..................................................................... 100
CAPÍTULO 6. CLASES DE USO COMÚN................................................. 101
ENTRADA Y SALIDA.............................................................................. 101
Flujos de entrada..................................................................................... 103
Flujos de salida........................................................................................ 104
Salida con formato................................................................................... 106
Excepciones............................................................................................ 108
Trabajar con tipos de datos numéricos...................................................... 109
Clases que encapsulan los tipos primitivos............................................ 110
Clase Leer.............................................................................................. 113
¿DÓNDE SE UBICAN LAS CLASES QUE DAN SOPORTE?................... 116
CARÁCTER FIN DE FICHERO................................................................. 116
CARACTERES \r\n..................................................................................... 118
MÉTODOS MATEMÁTICOS..................................................................... 120
NÚMEROS ALEATORIOS........................................................................ 122
EJERCICIOS RESUELTOS........................................................................ 122
EJERCICIOS PROPUESTOS..................................................................... 126
CAPÍTULO 7. SENTENCIAS DE CONTROL............................................ 129
SENTENCIA if........................................................................................... 129
ANIDAMIENTO DE SENTENCIAS if....................................................... 132
ESTRUCTURA else if................................................................................. 134
SENTENCIA switch.................................................................................... 137
SENTENCIA while..................................................................................... 140
Bucles anidados...................................................................................... 143
SENTENCIA do ... while............................................................................. 145
SENTENCIA for......................................................................................... 148
SENTENCIA foreach.................................................................................. 152
SENTENCIA break..................................................................................... 152
SENTENCIA continue................................................................................. 153
SENTENCIAS try ... catch.......................................................................... 153
EJERCICIOS RESUELTOS........................................................................ 155
EJERCICIOS PROPUESTOS..................................................................... 161
CAPÍTULO 8. MATRICES.......................................................................... 163
INTRODUCCIÓN A LAS MATRICES....................................................... 164
MATRICES NUMÉRICAS UNIDIMENSIONALES................................... 165
Declarar una matriz................................................................................. 165
Crear una matriz..................................................................................... 166
Iniciar una matriz..................................................................................... 167
Acceder a los elementos de una matriz..................................................... 167
Métodos de una matriz............................................................................. 168
Trabajar con matrices unidimensionales.................................................... 169
CADENAS DE CARACTERES.................................................................. 172
Clase String............................................................................................ 174
Clase StringBuilder.................................................................................. 180
Trabajar con cadenas de caracteres......................................................... 182
MATRICES MULTIDIMENSIONALES Y DE REFERENCIAS................. 185
Matrices numéricas................................................................................. 186
Matrices de cadenas de caracteres........................................................... 192
Matrices de objetos String o StringBuilder................................................. 196
SENTENCIA foreach.................................................................................. 198
EJERCICIOS RESUELTOS........................................................................ 199
EJERCICIOS PROPUESTOS..................................................................... 204
CAPÍTULO 9. MÁS SOBRE MÉTODOS.................................................... 207
PASAR UNA MATRIZ COMO ARGUMENTO A UN MÉTODO.............. 207
MÉTODO QUE RETORNA UNA MATRIZ............................................... 209
PASAR UN ARGUMENTO DE UN TIPO PRIMITIVO............................. 211
PASAR ARGUMENTOS EN LA LÍNEA DE ÓRDENES........................... 212
MÉTODOS RECURSIVOS......................................................................... 215
LA CLASE Array....................................................................................... 217
Clear...................................................................................................... 217
Sort........................................................................................................ 217
BinarySearch.......................................................................................... 218
Reverse.................................................................................................. 219
EJERCICIOS RESUELTOS........................................................................ 219
EJERCICIOS PROPUESTOS..................................................................... 223
CAPÍTULO 10. TRABAJAR CON FICHEROS......................................... 227
VISIÓN GENERAL DE LOS FLUJOS DE E/S........................................... 229
ABRIENDO FICHEROS PARA ACCESO SECUENCIAL......................... 229
Flujos de bytes........................................................................................ 230
FileStream.......................................................................................... 230
Flujos de caracteres................................................................................. 235
StreamWriter..................................................................................... 235
StreamReader.................................................................................... 238
Clases File, Directory y Path.................................................................... 239
Flujos de datos de tipos primitivos............................................................. 242
BinaryWriter...................................................................................... 242
BinaryReader..................................................................................... 244
Un ejemplo de acceso secuencial............................................................. 245
Escribir en un fichero.......................................................................... 246
Más sobre excepciones....................................................................... 248
Leer de un fichero.............................................................................. 249
ABRIENDO FICHEROS PARA ACCESO ALEATORIO........................... 251
Propiedades y métodos para acceso aleatorio............................................ 252
Position.............................................................................................. 252
Length............................................................................................... 252
Seek.................................................................................................. 253
La clase CPersona.................................................................................. 255
La clase CListaTfnos.............................................................................. 256
Constructor CListaTfnos..................................................................... 257
Escribir un registro en el fichero.......................................................... 259
Añadir un registro al final del fichero.................................................... 260
Leer un registro del fichero................................................................. 260
Eliminar un registro del fichero............................................................ 261
¿Hay registros marcados para eliminar?............................................... 262
Buscar un registro en el fichero........................................................... 262
Un ejemplo de acceso aleatorio a un fichero.............................................. 263
Modificar un registro........................................................................... 266
Actualizar el fichero............................................................................ 267
UTILIZACIÓN DE DISPOSITIVOS ESTÁNDAR...................................... 268
EJERCICIOS RESUELTOS........................................................................ 270
EJERCICIOS PROPUESTOS..................................................................... 289
APÉNDICES
A. AYUDA..................................................................................................... 291
B. CÓDIGOS DE CARACTERES................................................................ 293
C. ÍNDICE..................................................................................................... 297