Está en la página 1de 41

Microsoft C#™
Curso de programación
2ª edición
Fco. Javier Ceballos Sierra
Profesor titular de la
Escuela Politécnica Superior
Universidad de Alcalá

http://www.fjceballos.es

Microsoft C#: Curso de programación. 2ª edición.
© Fco. Javier Ceballos Sierra
© De la edición: RA-MA 2011

MARCAS COMERCIALES: Las marcas de los productos citados en el contenido de este libro
(sean o no marcas registradas) pertenecen a sus respectivos propietarios. RA-MA no está
asociada a ningún producto o fabricante mencionado en la obra, los datos y los ejemplos
utilizados son ficticios salvo que se indique lo contrario.

RA-MA es una marca comercial registrada.

Se ha puesto el máximo empeño en ofrecer al lector una información completa y precisa.
Sin embargo, RA-MA Editorial no asume ninguna responsabilidad derivada de su uso,
ni tampoco por cualquier violación de patentes ni otros derechos de terceras partes que pudieran
ocurrir. Esta publicación tiene por objeto proporcionar unos conocimientos precisos y acreditados
sobre el tema tratado. Su venta no supone para el editor ninguna forma de asistencia legal,
administrativa ni de ningún otro tipo. En caso de precisarse asesoría legal u otra forma de ayuda
experta, deben buscarse los servicios de un profesional competente.

Reservados todos los derechos de publicación en cualquier idioma.

Según lo dispuesto en el Código Penal vigente ninguna parte de este libro puede ser
reproducida, grabada en sistema de almacenamiento o transmitida en forma alguna ni
por cualquier procedimiento, ya sea electrónico, mecánico, reprográfico, magnético o
cualquier otro, sin autorización previa y por escrito de RA-MA; su contenido está protegido
por la Ley vigente que establece penas de prisión y/o multas a quienes intencionadamente,
reprodujeren o plagiaren, en todo o en parte, una obra literaria, artística o científica.

Editado por:
RA-MA Editorial
C/ Jarama, 3A, Polígono industrial Igarsa
28860 PARACUELLOS DEL JARAMA, Madrid
Teléfono: 91 658 42 80
Telefax: 91 662 81 39
Correo electrónico: editorial@ra-ma.com
Internet: www.ra-ma.es y www.ra-ma.com
ISBN: 978-84-9964-068-6
Depósito Legal: M-xxxxx-2011
Autoedición: Fco. Javier Ceballos
Filmación e impresión: Closas-Orcoyen, S.L.
Impreso en España
Primera impresión: Marzo 2011

.................................................... 11  Compilar y ejecutar el programa ........................................................................................................................ 11  Biblioteca de clases ........................................ XXVI PARTE 1........................................................ XXVI  Agradecimientos ................................................... XXVI  Sobre los ejemplos del libro .......... PROGRAMACIÓN BÁSICA ................ 3  LENGUAJES DE PROGRAMACIÓN................................................................................................................. 4  Compiladores ....................................................................... 7  ¿POR QUÉ APRENDER C#?.......................................................... 10  Guardar el programa escrito en el disco............................................................................................................................................................................................................................................................................................... 6  QUÉ ES C# ................... 15  ................................................................. XXIV  Cómo está organizado el libro.................................................................................................................... FASES EN EL DESARROLLO DE UN PROGRAMA .......... 9  Interfaz de línea de órdenes..................... 10  ¿Qué hace este programa?.... 3  QUÉ ES UN PROGRAMA............................ 14  Depurar un programa ....................................................................................................................................................................... 8  REALIZACIÓN DE UN PROGRAMA EN C# .......................... 8  Cómo crear un programa ..................... XXIII Para quién es este libro............................................... 14  Guardar el programa ejecutable en el disco ......................................................... 1 CAPÍTULO 1....................................... 6  Intérpretes................................................ XXV  Qué se necesita para utilizar este libro . CONTENIDO PRÓLOGO..............................................................................................

................................................................ 45  HERENCIA........ ELEMENTOS DEL LENGUAJE .......................... 36  Atributos .... 66  Literal null .............................................................................. 35  DISEÑO DE UNA CLASE DE OBJETOS ................. 69  ...... 15  EJERCICIOS PROPUESTOS........................................................................................................................................ 48  EJERCICIOS RESUELTOS .... 33  PENSAR EN OBJETOS ................................................... 25  EXPRESIONES ARITMÉTICAS ............................................................. 64  Literales reales .................... 22  AÑADIR COMENTARIOS .............................................................................................................................. 31 CAPÍTULO 3............................................................................................................ 63  LITERALES ................................................ INTRODUCCIÓN A LA POO ............................................. 68  DECLARACIÓN DE CONSTANTES SIMBÓLICAS .............................................................................................. 34  Clases y objetos ................................................................................................... 61  TIPOS............................................................................................................................................. 60 CAPÍTULO 4........................................................................................................ 15  EJERCICIOS RESUELTOS ............................................................................................................................ 55  EJERCICIOS PROPUESTOS........................... 19  DECLARACIÓN DE UNA VARIABLE ...................................................................................................................................................................................................... 29  EJERCICIOS PROPUESTOS........................................................................................................................................................................................................................................................................................ 34  Mensajes y métodos ............................................................................................................ 64  Literales enteros ........................................................................................ 17 CAPÍTULO 2. 66  Literales de cadenas de caracteres ............................................................................................... 67  IDENTIFICADORES .............................................. CURSO DE PROGRAMACIÓN Entorno de desarrollo integrado ................................................. INTRODUCCIÓN A C# ...................................................................................................................... 61  CARACTERES DE C# ....................................................... 26  EXPRESIONES CONDICIONALES ....................................................................... 24  MOSTRAR DATOS POR LA PANTALLA .... 19  ASIGNAR VALORES ...... 37  Propiedades y métodos........................................... 38  CONSTRUCTORES ...................................................................... 27  ESCRIBIR NUESTROS PROPIOS MÉTODOS.........X C# ....................................... 65  Literales de un solo carácter .................... 68  PALABRAS CLAVE .....................................................

.................................................................................................. CONTENIDO XI ¿Por qué utilizar constantes? ............................................................... 81 CAPÍTULO 5........................ 70  CONVERSIÓN ENTRE TIPOS PRIMITIVOS ............................. 110  Flujos de entrada ............................................................................................................................................................................................................................................ 94  Definición de un método ................................................................................... 95  Crear objetos de una clase ....................................................................................................................................................... 70  VARIABLES ............................................................................................ 101  Pasando argumentos a los métodos ....................... 73  Operadores lógicos ........................................................................ 93  Métodos............................. 109  ENTRADA Y SALIDA ......... 96  Protección de los miembros de una clase ... 73  Operadores unitarios ......................... 89  Directriz using ............................................................. 108 CAPÍTULO 6........................................................... 78  EJERCICIOS RESUELTOS ... 91  Especificación de alias ............. 79  EJERCICIOS PROPUESTOS.............................................. 72  OPERADORES............................... 104  Conversión entre tipos referencia.............................................................................................................................................. CLASES DE USO COMÚN ... 83  Espacios de nombres .......................................................................................................................................................................................... 97  Miembro de un objeto o de una clase.................................. 87  Protección de una clase ..................... 92  Sentencia simple .................................... 94  Método Main ................ 83  ESTRUCTURA DE UN PROGRAMA C# ................................ 91  Definiciones y declaraciones................................................... 78  PRIORIDAD Y ORDEN DE EVALUACIÓN ....................................................................................................................................................................... 74  Operadores a nivel de bits ........... ESTRUCTURA DE UN PROGRAMA ....................................................... 106  EJERCICIOS PROPUESTOS........................................................................................................................................................................................................................................................................................................................................... 93  Sentencia compuesta o bloque ................................................................. 74  Operadores de asignación .................................................................... 114  .......................... 111  Flujos de salida........................................................................................................................................ 106  EJERCICIOS RESUELTOS ...................................................................... 75  Operador condicional ........................................................................................... 113  Salida con formato ................................................................................................................................ 99  Referencias a objetos.................................................. 95  Cómo acceder a los miembros de un objeto ..........................................................................

................................................ 181  ............................................................. 156  SENTENCIA do ................................. MATRICES ......... 161  SENTENCIA foreach .......................................... 167  EJERCICIOS RESUELTOS ....................................................................................................................................................... 144  ESTRUCTURA else if .............................................................................................. 141  SENTENCIA if .............................................................................. 165  SENTENCIA continue .................. 131  MÉTODOS MATEMÁTICOS ..... 165  SENTENCIA break ........................................... 178  MATRICES NUMÉRICAS UNIDIMENSIONALES ............................................................................................................................................................... 118  Estructuras que encapsulan los tipos primitivos .............................................................................................................................. 153  Bucles anidados................... 179  Crear una matriz ...................................................................................................................................... 119  Conversión entre tipos valor y tipos referencia ............................................... 177  INTRODUCCIÓN A LAS MATRICES ..... 165  SENTENCIA goto .............................................................. 134  EJERCICIOS RESUELTOS ............................................ 180  Iniciar una matriz ................................................ 166  SENTENCIAS try ....................................... catch...................................................................................................................................................................................................................................................................................................... 122  ¿DÓNDE SE UBICAN LAS CLASES QUE DAN SOPORTE?........... 138 CAPÍTULO 7............ 121  Clase Leer ................................................................................ 129  Controlar la posición y los colores del texto .............................................. 158  SENTENCIA for ....XII C# ......................................... 174 CAPÍTULO 8. 131  Detección de las pulsaciones del teclado ............................................................. SENTENCIAS DE CONTROL .......... while ........................................ 134  EJERCICIOS PROPUESTOS.. 129  Dimensiones de la ventana de la consola ........................... 141  ANIDAMIENTO DE SENTENCIAS if .................................................................................................. 125  CARACTERES \r\n ............................................................................................................................................................................................................................... 169  EJERCICIOS PROPUESTOS................................................................................................................................................................................... CURSO DE PROGRAMACIÓN Excepciones .............................................................................................. 127  OTROS MÉTODOS DE LA CLASE Console ........................................................... 132  NÚMEROS ALEATORIOS ........................ 146  SENTENCIA switch ................................................................................................................... 149  SENTENCIA while ..................................................................................................................... 179  Declarar una matriz ................ 116  Trabajar con tipos de datos numéricos ..................................................... 125  CARÁCTER FIN DE FICHERO ..

......................................... 183  Matriz de tipo ArrayList ........................................................................................................ 187  Copiar listas ............................ 203  int Length ....................................................................... 190  Diccionario ................................................................................................ 203  StringBuilder([arg]) ............................................. 201  Operador de indexación ............................................ int ncars) ............................... 202  String Insert(int pos.................... 204  StringBuilder Insert(int índice............................................................................................... 186  Insertar un elemento ........................ CONTENIDO XIII Acceder a los elementos de una matriz ............... int nCars) ....................................................................... 197  String ToString() ............................................................................................................ 186  Buscar elementos .................................... String str2) ............................................................................................................................................................................... 195  Clase String ........................................................................................................................................................................... 200  String ToLower() .......................................................................... 204  ..................................... 201  bool EndsWith(String sufijo) ............................................. 182  Métodos de una matriz ....... 181  Tamaño y dimensión de una matriz ......... 201  String Substring(int pos........................................................................................ 204  StringBuilder Append(tipo x) ................. 199  int CompareTo(String otroString).............................................................................................................................................. 192  CADENAS DE CARACTERES ........................................................................................................................................................................................ 197  String(char[])........................................................................................................................................................................ 201  bool StartsWith(String prefijo) ............................................... String nuevaStr)............................................................................................... 200  String ToUpper().. 182  Trabajar con matrices unidimensionales ....... 202  String Replace(String str..... 187  Iteradores...................................................................... 204  int Capacity ................................................................................................................................ 198  void CopyTo(int IndFuente............. tipo x) ........................... 188  Matrices asociativas ....................................... String str) ............................................ 186  Obtener el valor de un elemento ........................................ char[] destino..................................... 186  Eliminar elementos ........................... 202  int IndexOfAny(char[] cad) ................................... 202  String[] Split(char[] seps)................................................... 201  String Trim() ........ 184  Añadir un elemento ............................................................................... 202  Clase StringBuilder ................................................. 199  int Length ............................................................................................................................................................... 187  Ejemplo ................................................................................................................. 198  static String Concat(String str1..................................................................................................... 186  Tamaño ....................................................................... 202  int IndexOf(String str)................................................. int IndDes................................................ 186  Modificar un elemento ....................................

............... 252  Colecciones predefinidas ............................. 246  int GetHashCode() .......................................................... 244  String ToString() ................................................... CURSO DE PROGRAMACIÓN StringBuilder Remove(int p............ 245  void Finalize() ........................................... 225  MÉTODO QUE RETORNA UNA MATRIZ ................................................................................................................................................XIV C# ........ 242  LA CLASE Object ................................................................................................................................................... 236  MÉTODOS SOBRECARGADOS ........... 223 CAPÍTULO 9.......................................................................... 260 ...................................................................................................................... 205  Operador de indexación .............................. 252  Crear una colección .................................................................................................................................................... 217  EJERCICIOS RESUELTOS ................ 205  String ToString() ............................................................ 254  EJERCICIOS RESUELTOS ................................. 233  PASAR ARGUMENTOS EN LA LÍNEA DE ÓRDENES ....................................... 244  bool Equals(Object obj) ........................ 227  PASAR UN ARGUMENTO DE UN TIPO PRIMITIVO ........................................................................................ 241  NÚMERO VARIABLE DE PARÁMETROS .................................................... 250  Sort ............. String nuevaStr........................ 231  PARÁMETROS DE SALIDA ......................................... int n) ................. 213  Matrices de objetos String o StringBuilder ........................ int n) ................................................ 214  SENTENCIA foreach .......................... 206  Matrices de cadenas de caracteres ............................ 251  Reverse .. int p........................................................................................ 255  EJERCICIOS PROPUESTOS.......... MÁS SOBRE MÉTODOS Y COLECCIONES .......... 246  MÁS SOBRE REFERENCIAS Y OBJETOS String ............................................................ 253  Colecciones genéricas ............................................................................ 229  PASAR TIPOS REFERENCIA POR REFERENCIA ......................................................................................................................... 240  PARÁMETROS CON VALOR POR OMISIÓN ........................................ 205  MATRICES MULTIDIMENSIONALES Y DE REFERENCIAS ............................................................................................................................................... 238  ARGUMENTOS CON NOMBRE .............................................................................................................................................................................................................................................................................................................................................................................................................. 250  BinarySearch ............................................... 246  LA CLASE Array ............ 249  Clear ........................................................................ 206  Matrices numéricas ..................... 234  MÉTODOS RECURSIVOS ................................................... 251  COLECCIONES ... 217  EJERCICIOS PROPUESTOS...................................................................................................................................................... 225  PASAR UNA MATRIZ COMO ARGUMENTO A UN MÉTODO .................... 205  StringBuilder Replace(String str............................................................................................

................................................................... 321  ................. 313  MÉTODOS EXTENSORES ................................................................................................................................................................................................................................................................................................................ 263 CAPÍTULO 10........................................................................... 305  Método Equals ............................ 305  MIEMBROS STATIC DE UNA CLASE ......... 265  Atributos ................................................ 273  IMPLEMENTACIÓN DE UNA CLASE ............................................ 271  Acceso público ............................................................................................... ESPACIOS DE NOMBRES Y ESTRUCTURAS ................................................................ 273  Acceso protegido ............ 311  CLASES ANIDADAS ...... 277  NÚMERO VARIABLE DE PARÁMETROS .......................................................................................................................................................................... CONTENIDO XV PARTE 2... 297  REFERENCIAS COMO MIEMBROS DE UNA CLASE ..................................................................................................................................................... 291  DESTRUCCIÓN DE OBJETOS... 289  Asignación de objetos ........................................................................................................................................... 269  Propiedades auto-implementadas .......................................................................... 270  Control de acceso a los miembros de la clase ... 307  Acceder a los atributos static........................................... 279  IMPLEMENTACIÓN DE UNA APLICACIÓN ............................................................................................................................................................................................................................................................... 280  CONTROL DE ACCESO A UNA CLASE .......................................................................... 288  Llamar a un constructor ........................................................................... 265  DEFINICIÓN DE UNA CLASE ................................. 297  REDEFINIR MÉTODOS HEREDADOS DE Object . 315  DELEGADOS ................................................................................................................................................. 281  REFERENCIA this ................................................. 295  Ejecutar el recolector de basura ................. 273  Acceso interno ........................................ 320  Expresiones lambda ..... 292  Destructor ................ 282  INICIACIÓN DE UN OBJETO ........................................... 284  Constructor .................. 309  Métodos static ......................................................................... 272  Acceso privado....................................... 317  Métodos anónimos .... 307  Atributos static .................................. 310  DECLARACIONES PARCIALES ................. 290  Constructor copia ..................................................................................................................... CLASES........................................................... 285  Sobrecarga del constructor ....................... MECANISMOS DE ABSTRACCIÓN.......................................................................................................................................................................................................................................... 293  Sentencia using .................................................................................................................................................................................................................................... 274  MÉTODOS SOBRECARGADOS ..................................... 267  Métodos de una clase ....................................................................................... 268  Propiedades .......

................................................................ 371  EJERCICIOS PROPUESTOS................. 385  Control de acceso a los miembros de las clases ..................................................................................................................... 411  Conversiones implícitas ...................... 333  Declarar espacios de nombres ................................................................ 324  MATRICES DE OBJETOS ..................XVI C# .............................................................................................................................................................. 393  REDEFINIR MÉTODOS DE LA CLASE BASE ......................................... 355  SOBRECARGA DE OPERADORES BINARIOS .................................................. 402  JERARQUÍA DE CLASES ........................................................................................... 361  Métodos adicionales .............................. 382  DEFINIR UNA CLASE DERIVADA ....................................... 349  UNA CLASE PARA NÚMEROS RACIONALES ....................................................................... 397  COPIA DE OBJETOS .................. 349  SOBRECARGAR UN OPERADOR ......................... 367  Conversiones explícitas......................................................................................................................................................................................................... 403  REFERENCIAS A OBJETOS DE UNA CLASE DERIVADA .... 363  Operadores unarios/binarios......................... 395  CONSTRUCTORES DE LAS CLASES DERIVADAS ............................................................................................................................................ 387  Qué miembros hereda una clase derivada ....................................................................................... 378 CAPÍTULO 12......................................................................................................................................................... 334  Operador :: ......... 335  ESTRUCTURAS .......... OPERADORES SOBRECARGADOS .. 336  EJERCICIOS RESUELTOS ...................................................... 358  Sobrecarga de operadores aritméticos .................................... 365  Conversiones implícitas ................................................................. 381  CLASES DERIVADAS Y HERENCIA ............................................................................ 359  Sobrecarga de operadores de relación ....... 369  EJERCICIOS RESUELTOS .... 361  SOBRECARGA DE OPERADORES UNARIOS ....................................................... CURSO DE PROGRAMACIÓN Multidifusión........................... 337  EJERCICIOS PROPUESTOS.......................... 388  ATRIBUTOS CON EL MISMO NOMBRE....... 344 CAPÍTULO 11.............................................................................. 358  Sobrecarga de operadores de asignación.......................................................................................... 400  DESTRUCTORES DE LAS CLASES DERIVADAS ................................................................. 368  INDEXACIÓN ..................................................... 364  CONVERSIONES PERSONALIZADAS ............ 412  ............................................................. 324  ESPACIO DE NOMBRES.............................................................................................. 359  Aritmética mixta......................................................................................................................................................................................... CLASES DERIVADAS E INTERFACES .........................................................................................

...................................................................................................................................... 444  Implementar múltiples interfaces .............. 445  EJERCICIOS RESUELTOS .............. 414  INFORMACIÓN DE TIPOS DURANTE LA EJECUCIÓN ................ 451  DEFINICIÓN DE CLASES GENÉRICAS .......................................................................................................................... 424  POLIMORFISMO.............................. 442  Utilizar una interfaz como un tipo ...................................................... 452  Valor predeterminado para una variable de tipo T .............................. 462  EJERCICIOS PROPUESTOS................................................ 470  Excepciones derivadas ..................................................................................................................................................................................................................................... 455  Herencia ......................... TIPOS Y MÉTODOS GENÉRICOS ......................................................... 438  Utilizar una interfaz ................... CONTENIDO XVII Conversiones explícitas........... 468  Lanzar una excepción............................................................. 469  Capturar una excepción ............... 444  Para qué sirve una interfaz ...... 437  Definir una interfaz ......................................................... 434  CLASES Y MÉTODOS ABSTRACTOS .... 458  DELEGADOS GENÉRICOS ............................ 461  EJERCICIOS RESUELTOS ................................. 457  MÉTODOS GENÉRICOS .......... 415  Constructores virtuales ...................................................................................................... 450 CAPÍTULO 13............................................................................................................. 424  MÉTODOS EN LÍNEA .................................................................................................... 442  Interfaces frente a herencia múltiple .................................................................. 421  Destructores virtuales ................................................................. 473  ........................ 446  EJERCICIOS PROPUESTOS... 473  Relanzar una excepción........................................... 464 CAPÍTULO 14...................................................... 435  CLASES Y MÉTODOS FINALES ................................... 465  EXCEPCIONES DE C# ................................................................................................................................................................................................................................ 437  Un ejemplo: la interfaz IFecha ............................................ 454  Parámetros de tipos genéricos ............................................................................................................................................................................................................................................... 472  Capturar cualquier excepción ......... 439  Clase abstracta frente a interfaz ................................................................................................................................................................................................................................................................................. EXCEPCIONES ......... 436  INTERFACES..................................................................................................................................................................... 467  MANEJAR EXCEPCIONES ...................... 459  Delegado genérico Predicate ............................................................................................................................................................................... 414  MÉTODOS VIRTUALES ..................................................................................

............................................................................. 475  FLUJO DE EJECUCIÓN ......... 533  ..................................................................................................................................................................................... 497  StreamWriter .................... 504  BinaryWriter ........................................................................................................................... 491  ABRIENDO FICHEROS PARA ACCESO SECUENCIAL .............................................................................................. 522  ¿Hay registros marcados para eliminar? ................... 523  Un ejemplo de acceso aleatorio a un fichero............................................................................................................................................................................................................................................................................... 517  Constructor CListaTfnos ............ 491  Flujos de bytes ...................................................................................................................................................... 497  StreamReader .......... 481  EJERCICIOS RESUELTOS .................... 521  Leer un registro del fichero ..... 487 CAPÍTULO 15......................................................................... 489  VISIÓN GENERAL DE LOS FLUJOS DE E/S.......................... 500  Clases File............................ 516  La clase CListaTfnos............................................................................................................................................................ 508  Leer de un fichero .......................................................... 507  Escribir en un fichero ..... 473  CREAR EXCEPCIONES ... Directory y Path............................. 514  La clase CPersona .............. 504  BinaryReader ................................................................................................................................................................................................................................................ 518  Escribir un registro en el fichero ............................................................. 501  Flujos de datos de tipos primitivos........................................................................................................................... 513  Position ........... 520  Añadir un registro al final del fichero ......XVIII C# ................ 514  Seek ........................................................................... 492  Flujos de caracteres ............................................................................................... 506  Un ejemplo de acceso secuencial .............................. 521  Eliminar un registro del fichero ............. 478  CUÁNDO UTILIZAR EXCEPCIONES Y CUÁNDO NO ........ 528  UTILIZACIÓN DE DISPOSITIVOS ESTÁNDAR ................................................... FLUJOS....... 527  Actualizar el fichero ................................................................................................. 524  Modificar un registro ............................................................................................................. 529  SERIACIÓN DE OBJETOS ...................................................................................................................................... 492  FileStream ..... 513  Propiedades y métodos para acceso aleatorio ............ 523  Buscar un registro en el fichero ............................... 513  Length ........................................................................................................... CURSO DE PROGRAMACIÓN BLOQUE DE FINALIZACIÓN .............................................................................................................................................................................................. 510  ABRIENDO FICHEROS PARA ACCESO ALEATORIO .................................................................................................. 481  EJERCICIOS PROPUESTOS.............................................................

571  Clase CListaCircularSE<T>........... 583  Clase CListaCircularDE<T> ............. 583  Ejemplo ......................................... 608  Utilización de la clase CArbolBinE<T> .................................................................................................................... 578  EJEMPLO .................................................. 568  Iteradores .................................................. 573  PILAS........ 615  ......... 596  Buscar un nodo en el árbol ................................. CONTENIDO XIX EJERCICIOS RESUELTOS .......................................................................................................................................................................................... 601  Utilización de la clase CArbolBinB<T> ......................................................................................... 593  ÁRBOLES BINARIOS DE BÚSQUEDA ...... 582  Lista circular doblemente enlazada ............................................... 551  Inserción de un elemento al comienzo de la lista ................................................................................................................................................................................................................................................................................................................................................ 595  Clase CArbolBinB<T> ................................................... 555  Recorrer una lista ............................................................................................................................................... 548  Listas lineales simplemente enlazadas ........ 548  Operaciones básicas ...................................................................................................... 542 PARTE 3.......................................................................... 599  Insertar un nodo en el árbol. 570  LISTAS CIRCULARES ......................................................... 600  Borrar un nodo del árbol ..................................................................................................................................................................... 604  ÁRBOLES BINARIOS PERFECTAMENTE EQUILIBRADOS ....... ESTRUCTURAS DINÁMICAS ........ 556  Borrar todos los elementos de una lista ....................................................................................................................................... 577  COLAS ............................. DISEÑO Y PROGRAMACIÓN ............................................. 607  Clase CArbolBinE<T> ......................................................................... 554  Inserción de un elemento en general ................................................................................................................................... 545 CAPÍTULO 16.................................................. 590  Árboles binarios ....................................................................................... 556  UNA CLASE PARA LISTAS LINEALES ....................................... 591  Formas de recorrer un árbol binario .................. 560  Alternativas al método Obtener ........................................................................ 613  EJERCICIOS RESUELTOS ........................................................................................................................................................... 552  Buscar en una lista un elemento con un valor x ................................................................................... 536  EJERCICIOS PROPUESTOS.......................................................... 547  LISTAS LINEALES .............................. 554  Borrar un elemento de la lista .............................................................................................................................................. 557  Clase genérica para listas lineales ............. 589  ÁRBOLES.. 580  LISTA DOBLEMENTE ENLAZADA ....................................................

......................................................................................................... 633  ORDENACIÓN DE DATOS ..................................................................... 675  EJERCICIOS PROPUESTOS..................... 645  Comparación de los métodos expuestos..................................................................................... 692  Un ejemplo ................. ALGORITMOS ....................................................................................................................................................................................... 643  Método quicksort ...... 684  Estados de un hilo ........................................................................................ 630 CAPÍTULO 17........ HILOS . 687  PROGRAMAR CON HILOS ........................ Acceso secuencial ....... 648  BÚSQUEDA DE DATOS .................................... 664  Matrices hash ......................................................................................................................................................................................................... 661  ALGORITMOS HASH .................... 667  Eliminación de elementos ............. 665  Método hash abierto ....................... 666  Método hash con desbordamiento ......................................................................................................................................................... 672  EJERCICIOS RESUELTOS ................................................................................................. 698  Hilos en segundo plano . 679  HILOS ............................................. 668  Clase CHashAbierto ......................................................................................................................................................................................................................................................................................................... 688  CREACIÓN Y DESTRUCCIÓN DE HILOS........................ 649  Búsqueda binaria ......................................... 640  Método de inserción .......................................................................................... 649  Búsqueda secuencial ............... Acceso aleatorio ........................................................................................................................ 690  Parámetros del método que ejecuta el hilo .............................................................................................. 679  CONCEPTO DE PROCESO .............................................................................................................................................. 686  Cuándo se debe crear un hilo .............................................................. 693  Espera activa y pasiva .................. CURSO DE PROGRAMACIÓN EJERCICIOS PROPUESTOS.............................................................................................................................................. 640  Método de la burbuja ......................................... 678 CAPÍTULO 18................................. 688  Resumen de los métodos y propiedades de Thread ... 688  Clase Thread ......................XX C# ............................................................................... 701  ...................................................................................... 654  Ordenación de ficheros........................................................................... 668  Un ejemplo de una matriz hash ............................................................................................................................ 654  Ordenación de ficheros................................................................................. 649  Búsqueda de cadenas ............................................................................................ 697  Finalizar un hilo ................. 650  ORDENACIÓN DE FICHEROS EN DISCO.............................................................................................. 633  RECURSIVIDAD ....

................................................................... CONTENIDO XXI Ciclo de vida de un hilo ............................................................................................................................................................ 718  ¿Por qué los métodos Almacenar y Obtener utilizan un bucle? ....................................................................................................................................................... 715  Monitor reentrante ....................................... 702  Preparado ....................................................................................................................... INTERFACES GRÁFICAS Y APLICACIONES PARA  INTERNET ........................................................ ............... 757  INTERFACES GRÁFICAS ........................................................................................................ 755 CAPÍTULO 19................................................................................................................................................................................................................................................................................................ 743  PLANIFICACIÓN DE HILOS ........................................................................................................................................................................... 730  Controladores de espera ...................... 771  Escribir los controladores de eventos ....................................................................................... 740  Interbloqueo ................ 764  Borrar un control ..................................................... 725  Objeto Mutex ............................................................................... 763  Dibujar los controles ............................... 745  EJERCICIOS RESUELTOS .... 707  Secciones críticas .......................................................................... 771  Icono de la aplicación .................... 769  Propiedades de los objetos .............................................................................. 769  Bloquear la posición de todos los controles ......................................... 710  Exclusión mutua........... 772  Guardar la aplicación ................................................. 703  Bloqueado ........................................................................................................................................... 743  GRUPO DE HILOS ........ 706  Objetos de sincronización ............................ 777  ................................................................................................................................... 703  Dormido .......... 709  Ejemplo que implementa una sección crítica .................................................................................................. 743  Asignar prioridades a los hilos ................... 749  EJERCICIOS PROPUESTOS.......................................................................................... 705  Mecanismos de sincronización ............................................ 705  SINCRONIZACIÓN DE HILOS . 729  Problema del productor-consumidor .............................. 758  Crear un nuevo proyecto .................................................................................................................................................. 726  Objeto Semaphore ............................. 717  Utilizar Wait y Pulse/PulseAll .......................... 760  El formulario .................................................... 704  Esperando.................................................................................................. 776  Crear soluciones de varios proyectos ...................................................................................................... 736  Detener un hilo de forma controlada............................................................................................................................................................................. 775  Propiedades del proyecto ........ 774  Verificar la aplicación .......................................................................

...... ENTORNO DE DESARROLLO..... APÉNDICES ............................................................................................. 800 B. 780  Crear un nuevo formulario Web .......................................... 788  Generar la aplicación Web y ejecutarla........... 804  INSTALAR MONODEVELOP ..... 795  VISUAL STUDIO........................................................................ 795  Ediciones de Visual Studio para profesionales ... 795  Ediciones Visual Studio Express .............................................. 779  ACCEDER A LA WEB ............................................................................................................................ 796  DEPURAR UNA APLICACIÓN ................................. 793 A.................. 778  Componentes de ADO.............. .......................................... 804  EJECUTAR UN PROGRAMA C# EN LÍNEA DE ÓRDENES ....................................NET............................................................................................ 796  APLICACIÓN DE CONSOLA.............. 785  Ciclo de vida de una página .............. 803  INSTALACIÓN DE MONO ....................................................................................................... 799  ARGUMENTOS EN LA LÍNEA DE ÓRDENES ...................................... 807  ÍNDICE ..............XXII C# ............................................................................................................................................................................................................ 809  ....................... 781  Agregar controles y texto a la página ................................................... 787  Crear controladores de eventos para los controles ............................................................................ 791 PARTE 4.......................................................................................................................... CURSO DE PROGRAMACIÓN ADO....NET ............................................ 805 C................................................................................................................................................................................................................................... CD .NET PARA LINUX .................................

La solución que Microsoft da a este problema es el lenguaje denominado C#. el tiempo necesario para desarrollar una aplicación resulta largo com- parado con otros lenguajes como Visual Basic. abordar el desarrollo de aplicaciones complejas con facilidad y rapidez pero sin sacrificar la potencia y el control que ofrecen C y C++. Es un poco como tomar todas las cosas buenas de Visual Basic y añadirlas a C++. una elevada productividad en el desarrollo de aplicaciones. Ambos lenguajes proporcionan al progra- mador el nivel de abstracción preciso para abordar el desarrollo de cualquier apli- cación por compleja que sea. pero. Esto elimina los errores de programación más comunes en C y C++. además de facilidad. Más que otra cosa. aunque eso sí. y a los de C y C++ en particular. que ofrecen. En los últimos tiempos C y C++ han sido los lenguajes más utilizados en el desarrollo de aplicaciones en general. sin olvidar que tiene un alcance com- pleto sobre la Web. la cual se caracteriza por proporcionar utilidades y servicios para sacar un provecho total tanto de la in- formática como de las comunicaciones. en general.NET. Pero. aunque recortando algunas de las tradiciones más ocultas y difíciles de conocer de C y C++. pronunciado C Sharp. PRÓLOGO C#. además. sacrifi- cando la flexibilidad que los desarrolladores de C y C++ requieren. así como mecanismos de bajo nivel para utilizar las características más avanzadas de las plataformas sobre las que se desarrolla. es actualmente. el objetivo de C# es permitir a todos los desarrolladores en general. uno de los lenguajes de programación más populares en Internet. Por ejemplo: . Se trata de un lenguaje moderno orientado a objetos que permite desarrollar una amplia gama de aplicaciones para la nueva plataforma Microsoft . junto con Java. La idea fundamental de esta obra es dar a conocer estas facetas del lenguaje C#. está disponible para el de- sarrollo de programas de propósito general.

como muchos lenguajes. Más aún. trabajar con ficheros. etc. Se trata de un software que se puede obtener de la red basado en un conjunto de herramientas de órdenes en línea para editar. ejecutar y de- purar programas C#. crear estructuras dinámicas. entre otros. diseñar interfaces gráficas de usuario. y aunque C# no inicia automáticamente las variables locales. De forma resumida. La primera parte está pensada para que en poco tiempo pueda convertirse en programador de aplicaciones C#.NET Framework Software Development Kit (SDK). permite trabajar con todo tipo de datos. Un capítulo final le introducirá también en otros conceptos como interfaces gráficas. Curso de programación se centra. esta mate- ria puede agruparse en los siguientes apartados: • Programación básica. • Diseño y programación. Y para esto. • Todos los objetos creados dinámicamente así como las matrices son iniciados a cero. en el apren- dizaje del lenguaje C#. • Mecanismos de abstracción. • C# unifica el sistema de tipos permitiendo ver a cada uno de ellos en el len- guaje como un objeto. potente y orientado a objetos. el compi- lador avisará siempre que se intente utilizar una antes de iniciarla. atacar a bases de datos. de la programación orientada a objetos y en el desarrollo de aplicaciones. C# permite escribir aplicaciones tanto para Internet como apli- caciones de propósito general. ¿qué necesita? Pues simplemente leer ordenadamente los capítulos del libro. C# es un len- guaje simple. CURSO DE PROGRAMACIÓN • El recolector de basura libera al programador del peso que conlleva el manejo manual de la memoria. Para quién es este libro Microsoft C#. esto es. Pero la mejor forma de ver el alcance de C# es utilizando directa- mente el paquete de desarrollo Microsoft . casi en su totalidad. compilar. para introducirle más bien en el lenguaje y en el manejo de la biblioteca de clases de . Su sintaxis incita al programador a generar programas modulares y fácilmente mantenibles. Actualmente en el mercado hay multitud de herramientas de programación C# como Microsoft Visual Studio en sus distintas versiones o SharpDevelop por citar algunas. La segunda parte abarca en profundidad la programación orientada a objetos. páginas Web y servicios Web.XXIV C#. En la primera parte el autor ha tratado de desarrollar aplicaciones sencillas. Resumiendo. resolviendo cada uno de los ejemplos que en ellos se detallan.

Por eso hay una tercera parte que se dedica a estudiar las estructuras dinámicas de datos. Y. privaría al lec- tor de saber que aún C# proporciona mucho más. clases derivadas. Pero si el autor finalizara el libro con las dos partes anteriores. pero sí habrá dado un paso importante. espacios de nombres. Los capítulos del 10 al 14 cubren la programación orientada a objetos (POO) en detalle: clases.NET Framework que en el diseño de clases de objetos. para Office. El 15 nos enseña a trabajar con ficheros con el fin de dise- ñar aplicaciones en las que los datos manipulados persistan de una ejecución a otra. sí ha tenido que quedar claro que un programa orientado a objetos sólo se compone de obje- tos. para Internet (páginas Web) y para móviles. aplicaciones para acceso a bases de datos. Cuando complete todas las partes. etc. se expli- ca cómo utilizar el EDI para escribir. los algoritmos de uso común. Es hora pues de entrar con detalle en la programación orientada a objetos. puede continuar con mi otro libro titulado Enciclopedia de Microsoft Visual C# que cubre ampliamente y con detalle el desarrollo de: aplicaciones que muestran una interfaz gráfica al usuario. in- terfaces y excepciones. Cómo está organizado el libro El libro se ha estructurado en los 19 capítulos especificados en el apartado Resu- men del contenido expuesto anteriormente. Los capítulos del 1 al 9 nos presentan la programación básica: tipos. todavía no sabrá todo lo que es posible hacer con C#. En ellos se expone cómo utilizar el entorno de desarrollo integrado (EDI) para C# denominado Microsoft Visual Studio. PRÓLOGO XXV . .es. El 16 presenta el diseño de estructuras dinámicas de datos: listas y árboles binarios. finalmente. métodos. los hilos. El 17 muestra los algoritmos de búsqueda y ordenación más comunes. ejecutar y depurar un programa o cómo pro- ceder para trabajar sobre la plataforma Linux. Todo ello se ha documentado con abundantes problemas resueltos. en el trabajo con interfaces gráficas y en aplicaciones que se ejecutan en un servidor. sobrecarga de operadores. Si a continuación quiere ampliar sus conocimientos. y a introducirle en el diseño de interfaces gráficas de usuario. estructuras. la cual tiene un elemento básico: la clase. El autor considera importante que antes de iniciar el estudio de este libro eche una ojeada a los apéndices. sentencias. el 19 nos introduce en el diseño de aplicaciones que muestran una interfaz de ventanas al usuario y en el desarrollo de aplicaciones para Internet. El 18 estudia la programación concurrente: hilos. matrices. Puede ver más detalles sobre este libro y otros en mi Web: www. No obstante.fjceballos.

deseo expresar mi agradecimiento a Microsoft Ibérica por poner a mi disposición. Francisco Javier Ceballos Sierra http://www.microsoft. CURSO DE PROGRAMACIÓN Qué se necesita para utilizar este libro Este libro ha sido escrito utilizando el paquete Microsoft . Sobre los ejemplos del libro El código fuente de todos los ejemplos del libro podrá descargarse. desde la página Web correspondiente al mismo. que forma parte del entorno de desarrollo Microsoft Visual Studio 2010 y que incluye todo lo necesario para escribir. el SDK y los entornos de desarrollo integrado que el estudio de esta obra requiere.NET Framework Softwa- re Development Kit (SDK) versión 4. y de todos los lectores en general.0. Por lo tanto. estoy francamente agradecido. basta con que instale en su máquina Microsoft Visual Studio 2010 en cualquiera de sus versiones o. según se indi- ca en el apéndice CD. de la Web de la editorial que publica el libro. También. depurar y ejecutar aplicaciones .XXVI C#.fjceballos. necesitaría descargar e instalar Visual Web Developer 2010 Express. sólo para la introducción al desarrollo de aplicaciones para Internet. como al- ternativa. Agradecimientos He recibido ayuda de algunas personas durante la preparación de este libro y. y. finalmente.com/express/ el paquete Visual C# 2010 Express. por ello. descargue e instale desde http://www. cons- truir. en particular.NET.es . Ambos paquetes incluyen el paquete SQL Server Express para traba- jar con bases de datos.

PARTE ________________________ _________________________________ __________________________________________ Programación básica • Fases en el desarrollo de un programa • Introducción a C# • Introducción a la POO • Elementos del lenguaje • Estructura de un programa • Clases de uso común • Sentencias de control • Matrices • Más sobre métodos y colecciones .

.

espacios de nombres y estructuras • Operadores sobrecargados • Clases derivadas e interfaces • Tipos y métodos genéricos • Excepciones • Flujos .PARTE ________________________ _________________________________ __________________________________________ Mecanismos de abstracción • Clases.

.

PARTE ________________________ _________________________________ __________________________________________ Diseño y programación • Estructuras dinámicas • Algoritmos • Hilos • Interfaces gráficas y aplicaciones para Internet .

.

PARTE ________________________ _________________________________ __________________________________________ Apéndices • Entorno de desarrollo • .NET para Linux • CD .

.

microsoft. el entorno proporcionará algún menú con las órdenes apropiadas para realizar dicho proceso. lo primero que hay que hacer una vez instalado es asegurarse de que las rutas donde se localizan las herramientas. Su descarga es gratuita. APÉNDICE A © F.com/express/ Ediciones Visual Studio Express Es la nueva línea de productos que expanden Visual Studio ofreciendo herramien- tas ligeras y sencillas de aprender y de usar para aficionados. Si no es así. las bibliotecas. • Visual C# Express Edition. Por ejemplo.J. • Visual Basic Express Edition. . • Visual Web Developer Express Edition. entusiastas y apren- dices que quieren crear sitios Web y aplicaciones para Windows. http://www. VISUAL STUDIO Visual Studio proporciona una variedad de herramientas tanto para desarrollado- res individuales como para equipos de desarrollo. algunos EDI sólo requieren la ruta donde se instaló el compilador.Ceballos/RA-MA ENTORNO DE DESARROLLO Cuando se utiliza un entorno de desarrollo integrado (EDI). Este proceso normalmente se ejecuta automáticamente durante el proceso de ins- talación de dicho entorno. en los EDI que se presentan a continuación las rutas a las que nos referimos quedan establecidas du- rante la instalación de los mismos. la documentación y los ficheros fuente hayan sido establecidas.

. la elección de una u otra dependerá del tipo de aplicación que deseemos construir. La figura siguiente muestra esta ventana: .. APLICACIÓN DE CONSOLA Para editar y ejecutar el programa HolaMundo que desarrollamos en el capítulo 1 utilizando cualquiera de las ediciones de Visual Studio. y con herramientas de software de ciclo de vi- da productivas. Word e InfoPath. o bien ejecutamos la orden Archivo > Nuevo proyecto. Partiendo de la página de inicio de MS Visual C# Express. ofrece una flexi- ble herramienta de desarrollo para desarrolladores de aplicaciones de línea de ne- gocio o programadores ocasionales que estén construyendo aplicaciones móviles. para crear un proyecto nuevo. • SQL Server Express Edition. soluciones sobre Microsoft Office System utilizando Excel. premiun y ultimate. • y Visual Studio Express for Windows Phone. Ediciones de Visual Studio para profesionales Visual Studio en sus versiones profesional. hacemos clic en Nuevo proyecto. La utilización de estas versiones requiere comprar una licencia.796 C#. integradas y extensibles que permiten a las empresas reducir la complejidad en la creación de soluciones orientadas a servicios. CURSO DE PROGRAMACIÓN • Visual C++ Express Edition. basadas en Windows o para la Web. Esta acción hará que se visualice una ventana que mostrará los tipos de plantillas que puede utilizar. los pasos a seguir son los siguientes: 1.

si no lo está. ejecute la orden Herramientas > Opciones > Pro- yectos y soluciones y seleccione esta opción en la ventana que se visualiza: Para nuestro ejemplo.cs. Para cambiar el nombre asignado al fichero . A continuación pulsamos el botón Aceptar y obtendremos el esqueleto del proyecto de acuerdo con la plantilla seleccionada. Después. especificamos el nombre del proyecto y su ubicación. APÉNDICE A: ENTORNO DE DESARROLLO 797 Para que la ventana anterior muestre la lista Ubicación y la caja Nombre de la solución tiene que habilitar. la opción “Guardar nuevos proyec- tos al crearlos”. Para ello. hace- . observe que el proyecto será creado en una carpeta con el mismo nombre. elegimos la plantilla “Aplicación de consola”.

A continuación editamos el código que compone el programa. elegiríamos el tipo de elemento que de- seamos añadir (por ejemplo Clase) y. podemos verificar que se trata de una aplicación de consola: Proyecto > Propiedades de HolaMundo > Aplicación > Tipo de re- sultado > Aplicación de consola. 2. CURSO DE PROGRAMACIÓN mos clic sobre Program. tam- bién podemos hacer este cambio a través de la ventana de propiedades. finalmente. Si necesitáramos añadir un fichero nuevo a este proyecto. Después.798 C#. antes de compilar la aplicación. puede establecer la configuración para expertos: Herramientas > Configuración > Configuración para expertos. Después. haríamos clic en el botón Agregar. por lo que la operación de añadir nuevos elementos será muy habitual.cs y utilizando el botón derecho del ratón. seleccio- namos del menú contextual que se visualiza la orden Cambiar nombre. además de otras opciones en los menús ya visualizados. . Para que el EDI muestre el menú Generar. Lo normal es que una aplicación esté compuesta por varias clases. haríamos clic con el botón derecho del ratón sobre el nombre del proyecto y seleccionaríamos Agregar > Nuevo elemento.

con el fin de observar el flujo seguido durante su ejecución. Por ejemplo. La acción de ejecutar el programa acarrea también su compilación si fuera necesario. para ejecutar el programa seleccionamos la orden Iniciar sin depurar del menú Depurar. con la finalidad de detectar las anomalías que producen un resultado final erróneo. El proceso de depuración consiste en ejecutar la aplicación paso a paso. para depurar una aplicación utilizando el depurador del entorno de desarrollo de Visual C# Express. así como los resultados intermedios que se van sucediendo. indistintamente por sentencias o por métodos. Los resultados de la compilación se muestran en la ventana Resultados. APÉNDICE A: ENTORNO DE DESARROLLO 799 3. Para compilar el programa. ejecute la orden Depurar > Paso por instruc- ciones y utilice las órdenes del menú Depurar o los botones correspondientes de la barra de herramientas (para saber el significado de cada botón. DEPURAR UNA APLICACIÓN ¿Por qué se depura una aplicación? Porque los resultados que estamos obteniendo con la misma no son correctos y no sabemos por qué. . Finalmente. o bien pulsamos las teclas Ctrl+F5. o bien pulsando la tecla F5. También puede ejecutar el programa seleccionando la orden Iniciar depura- ción del menú Depurar. ejecutamos la orden Generar HolaMundo del menú Generar. ponga el puntero del ratón sobre cada uno de ellos).

¿dónde se introducen estos argumentos? Haga clic sobre el nombre del proyecto con el botón derecho del ratón y seleccione la orden Propiedades. • Ejecutar hasta el cursor o Ctrl+F10. Si la línea a ejecutar coincide con una llamada a un método definido por el usuario. sino de una sola vez. coloque el punto de inserción sobre ella. Detiene el proceso de depuración. Pone o quita un punto de parada en la línea sobre la que está el punto de inserción. Ejecuta la aplicación paso a paso. Cuando un método definido por el usuario ha sido invocado para ejecutarse paso a paso. dicho método no se ejecutará paso a paso. ARGUMENTOS EN LA LÍNEA DE ÓRDENES Si ejecuta una aplicación desde el EDI que requiere argumentos en la línea de órdenes. Des- pués. seleccione la orden Iniciar sin de- purar (Ctrl+F5) del menú Depurar. CURSO DE PROGRAMACIÓN De forma resumida. • Alternar puntos de interrupción o F9. • Paso a paso por procedimientos o F10. dicho método también se ejecutará paso a paso. Para ver el valor de una variable. • Detener depuración o Mayús+F5. seleccione el panel Depurar y escriba los ar- gumentos según puede observar en la figura: . las órdenes disponibles para depurar una aplicación son las siguientes: • Iniciar depuración o F5. Para ejecutar la aplicación en un solo paso. Ejecuta la aplicación paso a paso. • Paso a paso para salir o Mayús+F11. Ejecuta el código que hay entre la últi- ma línea ejecutada y la línea donde se encuentra el punto de inserción. Inicia la ejecución de la aplicación en modo depura- ción hasta encontrar un punto de parada o hasta el final si no hay puntos de parada. • Paso a paso por instrucciones o F11. Si la línea a ejecutar coincide con una llamada a un método definido por el usua- rio. utilizando esta orden se puede finalizar su ejecución en un solo paso. en la ventana que se visualiza.800 C#.

APÉNDICE A: ENTORNO DE DESARROLLO 801 .

.

• Multilenguaje. Java. Mono actualmente soporta: . compatible con Microsoft .NET 4. etc.NET gracias al proyecto Mono. incluyendo x86.NET. Se ejecuta en Linux.J. Eiffel.0 (incluyendo LINQ y programa- ción dinámica). • La API es compatible con Microsoft ASP. x86-64.8 o superior. que se mostró interesada en colaborar con el desarrollo de este entorno de programación desde el principio. sobre todo del mundo Linux. Se puede desarrollar en C# 4. OS X. Silverlight y apli- caciones Windows Forms. F#. Python.0. así como otras herramientas de ayuda al desarrollo de aplicaciones multiplataforma (cross-platform. Oxygene. ha contado con el apoyo de algunos pesos pesados de la industria informática. BSD. y entre sus características destacan: • Entorno de desarrollo multiplataforma. Mono. PowerPC. VB 8. .NET PARA LINUX Los desarrolladores sobre GNU/Linux pueden ahora también desarrollar aplica- ciones multiplataforma basadas en . ARM. s390. Ruby. y WCF limitado.Ceballos/RA-MA . la compañía norteameri- cana Novell adquirió esta empresa y se constituyó en uno de sus principales pa- trocinadores.NET. etc. en su versión 2. para varias compu- tadoras/sistemas operativos). Más tarde. APÉNDICE B © F. ADO. incluye un compilador para C# y bibliote- cas de ejecución (runtimes) para Java y C#. excepto WPF.NET. y Microsoft Windows. EntityFramework y WF. Durante su desarrollo. empresa dirigida por el mejicano Miguel de Icaza. basada en Linux. Es el caso de Ximian. ¿Qué es Mono? Es un proyecto para construir una plataforma de desarrollo li- bre.

804 C#.exe . Para ejecutarlo.com.novell.WriteLine("Hola mundo!!!").com/pub/mono/download-stable/ EJECUTAR UN PROGRAMA C# EN LÍNEA DE ÓRDENES Escriba el programa HolaMundo.Console.exe.go-mono.mono-project. escriba la orden: mono HolaMundo. así como instrucciones para su utilización. desde el cual podrá descargarse el software correspondiente a Mono para las distintas plataformas anteriormente comentadas. Es conveniente que a través de la utilidad YaST (grupo Software) añada el repositorio que permite actualizar mono para openSUSE y que está indicado en la página de descargas de este proyecto: http://ftp. } } Ahora compile el programa escribiendo la orden: mcs HolaMundo. CURSO DE PROGRAMACIÓN Para más detalles sobre el futuro de este proyecto visite la página Web http://www.com/mono-downloads/ y siga las instrucciones que allí se le indican. En esta página encontrará también un enlace. Downloads. descargue Mono para la distibución que usted tiene instalada de la dirección de Internet http://www. INSTALACIÓN DE MONO Si instaló la distribución openSUSE ya tiene instalado Mono. En otro caso.cs utilizando un editor de texto sin formato: class HolaMundo { public static void Main(string[] args) { System.cs El resultado del proceso de compilación es el fichero HolaMundo.

se le requerirá privilegios de administrador (root).NET PARA LINUX 805 INSTALAR MONODEVELOP MonoDevelop es un entorno de desarrollo integrado (EDI) basado en el EDI SharpDevelop escrito para Windows. Para arrancarlo. Para instalarlo. en el diálogo que se visualiza busque los paquetes relacionados con MonoDevelop (Search: monodevelop) e instálelos. APÉNDICE B: . suponiendo que instaló la distribución openSUSE. inicie YaST: Sistema > Instalar software. muestre el navegador de aplicaciones y seleccione Mono Develop Environment del grupo Nuevas aplicaciones/Desarrollo: . Una vez haya iniciado YaST.