MANUAL DEL CURSO

PROGRAMACIÓN TECNOLOGÍAS DE LA INFORMACIÓN Y COMUNICACIÓN
MSC. DAVID OCHOA DEL TORO ING. ANA LILIA HERNÁNDEZ VIESCA ING. ANTONIO GARAY ESPINOZA

TORREÓN, COAH., DICIEMBRE 2011

Tecnologías de la Información y Comunicación

Contenido
Unidad I ................................................................................................................... 1 Programación Orientada a Objetos ...................................................................... 1 Objetos................................................................................................................. 2 ¿Qué es un Objeto? ......................................................................................... 2 ¿Qué se puede considerar como objeto? ......................................................... 2 Clases .................................................................................................................. 3 Clasificación: ..................................................................................................... 3 Objetos y clases ................................................................................................... 4 Dentro de una clase .......................................................................................... 5 Abstracción y encapsulamiento ........................................................................... 5 Herencia ............................................................................................................... 6 Polimorfismo ........................................................................................................ 8 Unidad II ................................................................................................................ 10 Origen y necesidad de un nuevo lenguaje ......................................................... 10 Características de C#......................................................................................... 11 Características generales del lenguaje .............................................................. 15 Iniciar C# ............................................................................................................ 16 Crear un proyecto .............................................................................................. 18

i

Tecnologías de la Información y Comunicación

Elementos de trabajo ......................................................................................... 19 Cómo crear aplicaciones de consola .............................................................. 19 Cómo crear aplicaciones con ventanas .......................................................... 21 Controles más usuales y sus características .................................................. 22 Propiedades, métodos y eventos comunes .................................................... 23 UNIDAD III............................................................................................................. 26 Identificadores y tipos de dato ........................................................................... 26 Variables o identificadores .............................................................................. 26 Tipos de Datos ................................................................................................ 27 Clase Console. .................................................................................................. 28 Método para Mostrar Dato en Pantalla ........................................................... 28 Mostrar un mensaje y el valor de las variables ............................................... 28 Leer datos del Teclado ................................................................................... 29 Clase Convert ................................................................................................... 30 Expresiones ....................................................................................................... 30 Expresiones Aritméticas ................................................................................. 31 Expresiones Relacionales, Lógicas o Booleanas ........................................... 32 Sentencias de Control ........................................................................................ 34 Sentencia if ..................................................................................................... 34 Opción Múltiple o Expresiones Multivaluadas: switch ..................................... 35

ii

........................................................... 38 Campos ..................................................................................................................... 39 Objeto ................................................ 36 Sentencia for................................................... 49 Unidad IV........................................................................................... 42 Método Main .................................... 55 Excepciones .............................while .................................................................................................................................................................. 44 Ejercicios ........................................................................................................................................................................................................................................................................... 50 Arreglo tipo Lista (Unidimesionales)................................................................. 52 Foreach.........................Tecnologías de la Información y Comunicación Sentencia While ................................................................................................................................. 35 Sentencia Instrucción do............................................................................................................................. 43 Comentarios .......................................................................................... 51 Crear Arreglo de Objetos .................................................... 38 Métodos ..................................................................................................................................................................................................................................................... 37 Creación de Clases ...................................................................................... 38 Namespace.......... 38 Clases .......................................................................... 52 Clase Array ............... 53 Ejercicios ............................................................................... 57 iii ................................................................................................... 50 Declaración de Vectores ..............

..................................................................................... 59 iv ...............Tecnologías de la Información y Comunicación Bibliografía .........

que conviene conocer y estudiar antes de nada. En este documento veremos brevemente los conceptos básicos de la programación orientada a objetos En seguida se mencionaran algunas características de la Programación Orientada a Objetos: En POO un programa es un grupo de objetos que interactúan entre ellos Cada objeto tiene un rol en la solución del problema. Cada objeto provee un conjunto de servicios (o métodos) Los servicios de un objeto son usados por otros objetos Los objetos tienen un estado. porque “filosofía” sólo hay una y lenguajes muchos. con su teoría y su metodología. La naturaleza única del diseño orientado por objetos se debe a su habilidad para construir basándose en tres conceptos importantes del diseño del software: Abstracción Ocultamiento de la información Modularidad 1 .Tecnologías de la Información y Comunicación UNIDAD I PROGRAMACIÓN ORIENTADA A OBJETOS La programación orientada a objetos es una “filosofía”. Dicho esto. lo normal es que toda persona que vaya a desarrollar aplicaciones orientadas a objetos aprenda primero la “filosofía” (o adquiera la forma de pensar) y después el lenguaje. Un lenguaje orientado a objetos es un lenguaje de programación que permite el diseño de aplicaciones orientadas a objetos. un modelo de programación. parte de ese estado será conocido por los demás y otra parte no.

tanto externos como de otros objetos específicos que se encuentran dentro del sistema.Tecnologías de la Información y Comunicación OBJETOS El término "orientación por objeto" significa que organizaremos el software como una colección de objetos que incorporan tanto estructuras de datos como procedimientos. en la cual las estructuras de datos y el comportamiento están solo aproximadamente conectados El desarrollo orientado por objetos es una nueva forma de pensar acerca del software basado sobre abstracciones que existen en el mundo real En este contexto. diseño e implantación ¿Qué es un Objeto? Un objeto es una entidad física o abstracta que tiene un comportamiento ante ciertos estímulos. El receptor del mensaje presta el servicio y devuelve una respuesta al que solicitó el servicio Una descripción adecuada de los objetos debe: Ser precisa y no ambigua Ser completa No debe especificar más de lo necesario ¿Qué se puede considerar como objeto? Persona 2 . La forma en que los objetos se comunican entre ellos es a través de mensajes: Un mensaje encapsula la petición de un servicio. el desarrollo es referido a la primera parte del ciclo de vida del software: análisis. Esto contrasta con la programación convencional.

El envío de mensajes es la única forma para que un objeto realice una operación. éste no puede ser manipulado directamente desde el exterior y su representación concreta es invisible. se dice que el estado interno del objeto (el valor de sus datos) está encapsulado.Tecnologías de la Información y Comunicación Equipo Hardware Materiales Información Software Procesos Procedimientos Relaciones o asociaciones entre objetos INCLUSO Entes matemáticos o lógicos Un objeto empaqueta datos (una representación concreta) y procedimientos que operan sobre los datos. Los objetos que pertenecen a una clase se describen colectivamente por la definición de una clase. Una clase es la abstracción que describe propiedades importantes para una aplicación. Las operaciones son la única forma para cambiar el estado de los datos. Cuando esto se cumple. CLASES Clasificación: El proceso de clasificación es el enfoque central de la orientación por objeto y concierne a la agrupación de objetos con propiedades (estructuras de datos o atributos) y comportamiento (operaciones) similares dentro de una clase. En lugar de describir los objetos individuales la orientación 3 .

Primera: nombre de la clase. es una instancia específica de su clase Una clase se representa por una caja la cual puede tener 3 regiones. Sin embargo.Tecnologías de la Información y Comunicación por objeto concentra en un patrón tanto el estado como el comportamiento que es común a todos los objetos de la clase OBJETOS Y CLASES La distinción entre una clase y sus instancias (objetos) es similar a la distinción entre una definición de tipo y la declaración de una variable en un lenguaje de programación convencional. Clase: Tipo de datos definido por el usuario Objeto: Es un dato del tipo definido por su clase. la mayoría de los sistemas orientados por objeto crean dinámicamente instancias (objetos) por envío de mensajes "Nuevo" y "Crear" una clase. 4 . es decir.

ABSTRACCIÓN Y ENCAPSULAMIENTO Dos características fundamentales de la POO 5 . Tercera: contiene los nombres de los métodos.Tecnologías de la Información y Comunicación Segunda: contiene la lista de atributos. Los miembros de una clase (propiedades y métodos) pueden ser: o Públicos: se puede acceder a ellos desde fuera de la clase. cada nombre de atributo puede estar seguido por detalles opcionales tales como tipo de atributo y valores por defectos. cada nombre puede ser seguido por detalles opcionales tales como listas de argumentos y tipos de resultados. Para acceder a propiedades privadas de la clase se definen métodos de acceso. Fases de la vida de un objeto Creación de un objeto o Primero debe declararse o Luego debe ser instanciado Utilización del objeto instanciado Destrucción del objeto instanciado Dentro de una clase Campos de datos dentro de una clase: variables miembros o propiedades de la clase. Métodos con los datos de una clase: funciones miembros o métodos de la clase. o Protegido: sólo se puede acceder a ellos desde dentro de la clase o de las clases heredadas. o Privados: sólo se puede acceder a ellos desde dentro de la clase. Un miembro puede ser estático.

En un sentido más específico. Esto permite aumentar la cohesión de los componentes del sistema. una abstracción es una representación concisa de una idea o de un objeto complicado. Encapsulamiento: Significa reunir a todos los elementos que pueden considerarse pertenecientes a una misma entidad. y "comunicarse" con otros objetos en el sistema sin revelar cómo se implementan estas características. Solo es desde las clases. la abstracción localiza y oculta los detalles de un modelo o diseño para generar y manipular objetos. Los procesos. informar y cambiar su estado.Tecnologías de la Información y Comunicación Abstracción: Denota las características esenciales de un objeto. Cada objeto en el sistema sirve como modelo de un "agente" abstracto que puede realizar trabajo. Cerrado (Private). donde se capturan sus comportamientos. Tipos de encapsulamiento: • • • Abierto (Public): Puede accederse de cualquier parte del programa. Solo es accesible desde las clases y sus clases HERENCIA La herencia consiste en el compartir atributos y métodos entre clases basándose en una relación jerárquica. 6 . al mismo nivel de abstracción. Protegido (Protect): heredadas. las funciones o los métodos pueden también ser abstraídos En el sentido más general. Una clase puede definirse ampliamente y redefinirse sucesivamente en subclases más refinadas. principalmente porque se suelen emplear conjuntamente. Algunos autores confunden este concepto con el principio de ocultación.

Tecnologías de la Información y Comunicación Cada subclase que se incorpora. Estos pueden compartir (y extender) su comportamiento sin tener que volver a implementarlo. Las clases que heredan propiedades de otra clase pueden servir como clase base de otras. La herencia permite reutilizar código Las clases no están aisladas. 7 . Los objetos heredan las propiedades y el comportamiento de todas las clases a las que pertenecen. al ser posible reutilizar el mismo a lo largo de diferentes clases/objetos con comportamientos similares para un determinado aspecto. hereda todas las propiedades de su superclase y adiciona sus propias y únicas propiedades. sino que se relacionan entre sí. formando una jerarquía de clasificación. añadiendo código o modificando lo heredado. Esto suele hacerse habitualmente agrupando los objetos en clases y estas en árboles o enrejados que reflejan un comportamiento común. La clase derivada puede heredar código y datos de la clase base. Para ello es necesario que exista una clase base y una jerarquía de clases. Los objetos pueden ser construidos a partir de otros similares. La herencia organiza y facilita el polimorfismo y el encapsulamiento permitiendo a los objetos ser definidos y creados como tipos especializados de objetos preexistentes. Tipos herencias • • Simple Múltiple Ventajas Ayuda a los programadores a ahorrar código y tiempo.

De esta forma podemos tener un puntero a un objeto de la clase Trabajador. Las primeras son aquellas funciones que pueden evaluarse o ser aplicadas a diferentes tipos de datos de forma indistinta. 8 . El polimorfismo existe gracias a la herencia. En la práctica: un puntero a un tipo puede contener varios tipos diferentes. dependiendo del objeto.Tecnologías de la Información y Comunicación POLIMORFISMO Es la posibilidad de definir de forma distinta un método. pero este puntero puede estar apuntando a un objeto subclase de la anterior como podría ser Marketing. El concepto de polimorfismo se puede aplicar tanto a funciones como a tipos de datos. por su parte. Así nacen los conceptos de funciones polimórficas y tipos polimórficos. Capacidad que tienen los objetos de una clase de responder al mismo mensaje o evento en función de los parámetros utilizados durante su invocación. Ventas o Recepcionistas (todas ellas deberían ser subclase de Trabajador). no solo el creado. son aquellos tipos de datos que contienen al menos un elemento cuyo tipo no está especificado. Un objeto polimórfico es una entidad que puede contener valores de diferentes tipos durante la ejecución del programa. los tipos polimórficos.

puede ser utilizado a todo tipo de datos compatible.Tecnologías de la Información y Comunicación Se puede clasificar en dos grandes clases: Polimorfismo dinámico (o polimorfismo paramétrico): Aquél en el que el código no incluye ningún tipo de especificación sobre el tipo de datos sobre el que se trabaja. 9 . Polimorfismo estático (o polimorfismo ad hoc): Aquél en el que los tipos datos a los que se aplica el polimorfismo deben ser explicitados y declarados uno por uno antes de poder ser utilizados. Así. pero difieren en el número. Según la herencia puede clasificarse en Sobreescritura: reemplazar los métodos de la superclase en las subclases. Sobrecarga: varios métodos se llaman igual. tipo u orden de sus argumentos.

se suele decir que C# es el lenguaje nativo de . Un lenguaje que hubiese sido ideal utilizar para estos menesteres es Java.Tecnologías de la Información y Comunicación UNIDAD II ORIGEN Y NECESIDAD DE UN NUEVO LENGUAJE C# (leído en inglés “C Sharp” y en español “C Almohadilla”) es el nuevo lenguaje de propósito general diseñado por Microsoft para su plataforma . pero debido a problemas con la empresa creadora del mismo -Sun-. Sus principales creadores son Scott Wiltamuth y Anders Hejlsberg. su sencillez y el alto nivel de productividad son comparables con los de Visual Basic. Aunque es posible escribir código para la plataforma . Por esta razón. Microsoft ha tenido que desarrollar un nuevo lenguaje que añadiese a las ya probadas virtudes de Java las modificaciones que Microsoft tenía pensado añadirle para mejorarlo aún más y hacerlo un lenguaje orientado al desarrollo de componentes. En resumen. C# es un lenguaje de programación que toma las mejores características de lenguajes preexistentes como Visual Basic.NET. por lo que programarla usando C# es mucho más sencillo e intuitivo que hacerlo con cualquiera de los otros lenguajes ya que C# carece de elementos heredados innecesarios en . Java o C++ y las 10 . C# es el único que ha sido diseñado específicamente para ser utilizado en ella.NET en muchos otros lenguajes.NET.NET La sintaxis y estructuración de C# es muy parecida a la de C++ o Java. puesto que la intención de Microsoft es facilitar la migración de códigos escritos en estos lenguajes a C# y facilitar su aprendizaje a los desarrolladores habituados a ellos. Sin embargo. éste último también conocido por haber sido el diseñador del lenguaje Turbo Pascal y la herramienta RAD Delphi.

Por ejemplo: El código escrito en C# es auto contenido. El hecho de ser relativamente reciente no implica que sea inmaduro. lo que significa que no necesita de ficheros adicionales al propio fuente tales como ficheros de cabecera o ficheros IDL El tamaño de los tipos de datos básicos es fijo e independiente del compilador.NET Framework SDK. herencia múltiple o la necesidad de un operador diferente del punto (. sistema operativo o máquina para quienes se compile (no como en C++). CARACTERÍSTICAS DE C# Con la idea de que los programadores más experimentados puedan obtener una visión general del lenguaje. como un tipo básico decimal que permita realizar operaciones de alta precisión con reales de 128 bits 11 .NET en general. lo que facilita la portabilidad del código.) acceder a miembros de espacios de nombres (::) Modernidad: C# incorpora en el propio lenguaje elementos que a lo largo de los años ha ido demostrándose son muy útiles para el desarrollo de aplicaciones y que en otros lenguajes como Java o C++ hay que simular. por lo que su compilador es el más depurado y optimizado de los incluidos en el . No se incluyen elementos poco útiles de lenguajes como C++ tales como macros. a continuación se recoge de manera resumida las principales características de C# Alguna de las características aquí señaladas no son exactamente propias del lenguaje sino de la plataforma . y si aquí se comentan es porque tienen una repercusión directa en el lenguaje: Sencillez: C# elimina muchos elementos que otros lenguajes incluyen y que son innecesarios en .Tecnologías de la Información y Comunicación combina en uno solo. pues Microsoft ha escrito la mayor parte de la BCL usándolo.NET.

Es decir.C# sólo admite herencia simple de clases ya que la múltiple provoca más quebraderos de cabeza que facilidades y en la mayoría de los casos su utilidad puede ser simulada con facilidad mediante herencia múltiple de interfaces. aunque eso es más bien una característica del CTS que de C#. la inclusión de una instrucción foreach que permita recorrer colecciones con facilidad y es ampliable a tipos definidos por el usuario. C# es un lenguaje orientado a objetos. De todos modos. lo que reduce problemas por conflictos de nombres y facilita la legibilidad del código. En lo referente a la encapsulación es importante señalar que aparte de los típicos modificadores public. la sintaxis de C# permite definir cómodamente propiedades (similares a campos de acceso controlado). herencia y polimorfismo. que puede combinarse con protected e indica que al elemento a cuya definición precede sólo puede accederse desde su mismo ensamblado. eventos (asociación controlada de funciones de respuesta a notificaciones) o atributos (información sobre un tipo o sus miembros) 12 . C# soporta todas las características propias del paradigma de programación orientada a objetos: encapsulación. private y protected. la inclusión de un tipo básico string para representar cadenas o la distinción de un tipo bool específico para representar valores lógicos. Una diferencia de este enfoque orientado a objetos respecto al de otros lenguajes como C++ es que el de C# es más puro en tanto que no admiten ni funciones ni variables globales sino que todo el código y datos han de definirse dentro de definiciones de tipos de datos.Tecnologías de la Información y Comunicación (muy útil en el mundo financiero). esto vuelve a ser más bien una característica propia del CTS que de C#. Respecto a la herencia -a diferencia de C++ y al igual que Java. C# añade un cuarto modificador llamado internal. Orientación a objetos: Como todo lenguaje de programación de propósito general actual. Orientación a componentes: La propia sintaxis de C# incluye elementos propios del diseño de componentes que otros lenguajes tienen que simular mediante construcciones más o menos complejas.

y entre un tipo y un tipo hijo suyo del que un objeto del primero almacenase una referencia del segundo (downcasting) Obviamente.NET tiene a su disposición el recolector de basura del CLR. Esto es. lo último sólo puede comprobarlo en tiempo de ejecución el CLR y no el compilador. • Instrucciones seguras: Para evitar errores muy comunes. C# también proporciona un mecanismo de liberación de recursos determinista a través de la instrucción using. El compilador da a los campos un valor por defecto consistente en ponerlos a cero y controla mediante análisis del flujo de control de la fuente que no se lea ninguna variable local sin que se le haya asignado previamente algún valor. Sin embargo. en C# se han impuesto una serie de restricciones en el uso de las instrucciones de control más 13 . Seguridad de tipos: C# incluye mecanismos que permiten asegurar que los accesos a tipos de datos siempre se realicen correctamente. No se pueden usar variables no inicializadas. entre tipos para los que explícitamente se haya definido un operador de conversión. dado que la destrucción de los objetos a través del recolector de basura es indeterminista y sólo se realiza cuando éste se active –ya sea por falta de memoria. Esto tiene el efecto en el lenguaje de que no es necesario incluir instrucciones de destrucción de objetos. entre un tipo y antecesores suyos. lo que permite evita que se produzcan errores difíciles de detectar por acceso a memoria no perteneciente a ningún objeto y es especialmente necesario en un entorno gestionado por un recolector de basura. por lo que en realidad el CLR y el compilador colaboran para asegurar la corrección de las conversiones. Se comprueba que todo acceso a los elementos de una tabla se realice con índices que se encuentren dentro del rango de la misma.Tecnologías de la Información y Comunicación Gestión automática de memoria: Como ya se comentó. Para ello se toman medidas del tipo: Sólo se admiten conversiones entre tipos compatibles. finalización de la aplicación o solicitud explícita en el fuente-. todo lenguaje de .

con lo que se evitan errores por confusión del operador de igualdad (==) con el de asignación (=). la posibilidad de añadir a los metadatos del módulo resultante de la compilación de cualquier fuente información adicional a la generada por el compilador que luego podrá ser consultada en tiempo ejecución a través de la librería de reflexión de . Para evitar que esto ocurra. lo que evita la ejecución accidental de casos y facilita su reordenación. Si una clase introduce un nuevo método cuyas redefiniciones deban seguir la regla de llamar a la versión de su padre en algún punto de su código. que más bien es una característica propia de la plataforma .cuando se apliquen a diferentes tipos de objetos. la clase hija dejará de funcionar. • Extensibilidad de modificadores: C# ofrece. • Versionable: C# incluye una política de versionado que permite crear nuevas versiones de tipos sin temor a que la introducción de nuevos miembros provoquen errores difíciles de detectar en tipos hijos previamente desarrollados y ya extendidos con miembros de igual nombre a los recién introducidos. o si introduce un nuevo campo con el mismo nombre que algún método de una clase hija. y todo caso de un switch ha de terminar en un break o gota que indique cuál es la siguiente acción a realizar. la guarda de toda condición ha de ser una expresión condicional y no aritmética.Tecnologías de la Información y Comunicación comunes. puede usarse como un mecanismo para definir nuevos modificadores. tanto para conversiones implícitas como explícitas. difícilmente seguirían esta regla miembros de su misma signatura definidos en clases hijas previamente a la definición del mismo en la clase padre.NET . Esto. a través del concepto de atributos.NET y no de C#. al igual que C++ y a diferencia de Java. en C# se toman dos medidas: 14 . C# permite redefinir el significado de la mayoría de los operadores -incluidos los de conversión. Extensibilidad de operadores: Para facilitar la legibilidad del código y conseguir que los nuevos tipos de datos básicos que se definan a través de las estructuras estén al mismo nivel que los básicos predefinidos en el lenguaje. Por ejemplo.

Para ello basta marcar regiones de código como inseguras (modificador unsafe) y podrán usarse en ellas punteros de forma similar a cómo se hace en C++. en C# todo el código incluye numerosas restricciones para asegurar su seguridad y no permite el uso de punteros. sino que el CLR también ofrece. CARACTERÍSTICAS GENERALES DEL LENGUAJE C# es un lenguaje de propósito general orientado a objetos que permite realizar aplicaciones bajo una plataforma de desarrollo. Nótese que la capacidad de usar punteros en código inseguro permite que se pueda acceder con facilidad a este tipo de funciones. ya que éstas muchas veces esperan recibir o devuelven punteros. Sin embargo.net disponible en la página de Microsoft. la posibilidad de acceder a código nativo escrito como funciones sueltas no orientadas a objetos tales como las DLLs de la API Win32. en C# es posible saltarse dichas restricciones manipulando objetos a través de punteros. y a diferencia de Java. C++ directamente en código escrito en C# fragmentos de código escrito en estos lenguajes. • Compatible: Para facilitar la migración de programadores. NET FRAMEWORK. a través de los llamados Platform Invocation Services (PInvoke).Tecnologías de la Información y Comunicación • Eficiente: En principio. Ambiente en el desarrollo: El ambiente de desarrollo en C# se compone como lo siguiente: a) MARCO DE TRABAJO Es necesario el marco de trabajo denominado microsoft. C# no sólo o Java que permite incluir mantiene una sintaxis muy similar a C. b) EDITOR DE PROGRAMAS 15 . lo que puede resultar vital para situaciones donde se necesite una eficiencia y velocidad procesamiento muy grandes.

La Página de inicio aparece en primer plano.exe que viene incluido en microsof. INICIAR C# Al iniciar Visual Studio por primera vez nos encontramos con un entorno como el que aparece en la figura 1.net: este compilador produce archivos con extencio. d) BIBLIOTECA DE CLASES La biblioteca de clases de Microsoft.1 (página siguiente). En caso de C# la biblioteca de clases se instala y está disponible en el equipo al instalar Microsoft.net está formada por 6000 clases que permiten cualquier cosa prácticamente. una barra de botones debajo y una serie de ventanas adosadas.net framework. la herramienta más sofisticada para la programación de dicho programa es visual estudio. ofreciendo una lista de los proyectos en los que hemos trabajado recientemente (vacía por ahora) y enlaces para abrir y crear otros proyectos.net c) COMPILADOR DE PROGRAMAS El compilador de programas en C# es el programa csc. una ventana que nos servirá para gestionar los elementos que forman parte de cada proyecto. La parte derecha del entorno está ocupada por el Explorador de soluciones. con elementos habituales como un menú de opciones.exe. 16 . Esta página estará vacía si no disponemos de una conexión a la red.Tecnologías de la Información y Comunicación Aunque se puede editar programas en C# en cualquier editor de texto plano. debajo una lista de accesos directos a temas de la ayuda y a la derecha una serie de hipervínculos a noticias relacionadas con el producto obtenidas a través de Internet.

de tal forma que un simple clic nos llevará de una a otra. Podemos cerrar todas aquellas ventanas que no utilicemos con frecuencia. aparece una serie de iconos: Este botón da paso a un menú desplegable que nos permite establecer la configuración de la ventana.1. para liberar así el entorno y tener más espacio libre. Este icono aparece en las ventanas que se encuentran acopladas. ocultarla automáticamente. Situando el puntero del ratón sobre esa pestaña se abrirá la ventana. dejarla flotante. Al hacer clic sobre él la ventana pasa a ocultarse automáticamente cuando no está en uso. que volverá a ocultarse automáticamente cuando no se use a menos que hagamos clic sobre este icono.Tecnologías de la Información y Comunicación Observe la parte superior de ese panel: en el extremo derecho. El área central del entorno. Figura 1. Por cada página abierta aparecerá una pestaña en la parte superior. quedando visible únicamente una pestaña. Aspecto inicial del entorno de desarrollo. este icono sirve para cerrar la ventana. correspondiente al Cuadro de herramientas que se encuentra oculto. eligiendo entre acoplarla a otras (estado en el que se encuentra por defecto). De manera similar a como utiliza la combinación de teclas Alt-Tab para cambiar entre las aplicaciones abiertas en el sistema. encontrándose en el entorno de Visual C# 2005 Express Edition puede recurrir al atajo de teclado Control-Tab para navegar por las páginas abiertas en el área central del entorno. etc. En el margen superior izquierdo de la figura 1. 17 . donde ahora mismo se encuentra la Página de inicio. En cualquier momento podemos recurrir a las opciones del menú Ver para volver a abrir las que nos interesen. Como es fácil imaginar. sirve para ir mostrando las ventanas de los distintos editores y diseñadores con que cuenta el producto. tras el título.1 puede ver una pestaña con el título Toolbox.

3. en forma de iconos semitransparentes (véase la figura 1. sino que podemos colocarlas donde más cómodo nos resulte. podemos hacer clic en el enlace Crear proyecto que aparece en la parte inferior de la sección Proyectos recientes. mostrando la ventana con que cuenta la aplicación en un principio. 18 . Transcurridos unos segundos aparecerán los elementos del nuevo proyecto en la ventana Explorador de soluciones. Durante el proceso aparecerán unas guías. que facilitan la operación.3.2). CREAR UN PROYECTO Si tenemos abierta la Página de inicio. a las que se añadirán otras que podamos localizar mediante la opción Buscar plantillas en línea que aparece en la parte inferior. Inicialmente hay disponibles media docena de plantillas. Basta con tomar la ventana por la barra de título y arrastrarla allí donde interese. Cuadro de diálogo desde el que iniciaremos un nuevo proyecto. en el que se enumeran las plantillas de proyectos que tenemos instaladas. Basta con llevar el punto del ratón a uno de los estos iconos para acoplar la ventana a uno de los márgenes o apilarla como una página más. Figura 1. la ventana que hay inicialmente a la derecha. viendo de forma interactiva dónde quedaría antes de que la soltemos. En cualquier caso siempre nos encontraremos con el cuadro de diálogo que aparece en la figura 1.Tecnologías de la Información y Comunicación Las ventanas no tienen una posición fija en el entorno. También podemos sencillamente pulsar el botón Nuevo proyecto. elegir la opción Archivo> Nuevo proyecto del menú principal o pulsar la combinación de teclas ControlMayús-N. que por defecto es el primero de izquierda a derecha en la barra de botones. Por el momento aceptaremos las opciones propuestas por defecto: Aplicación para Windows con el nombre WindowsApplication1 y pulsaremos el botón Aceptar. y en el área de contenido se abrirá el diseñador de formularios Windows.

En la ventana Nuevo proyecto encontramos un elemento que es el encargado de generar una nueva aplicación de consola.Console a fin de acceder a la consola. conteniendo el método Main y cualquier otro adicional que pudiéramos necesitar. y no cuentan con una interfaz gráfica basada en ventanas. El uso de la consola de texto resulta adecuado cuando la interacción con el usuario es lo suficientemente sencilla como para no precisar más que la introducción de datos por teclado. hacer clic en el botón adecuado para dejarla adosada. enviando y recogiendo información. En cuanto a su estructura. Cómo crear aplicaciones de consola Las aplicaciones de consola reciben este nombre porque se ejecutan en la consola del sistema. Método(parámetros). No tenemos más que situar el cursor sobre la pestaña que tiene el título de la ventana y. lo que significa que no es necesario crear un objeto Console para poder invocarlos sino que podemos usar la notación Console. concretamente con el Cuadro de herramientas y la ventana Propiedades. Para hacer visible la segunda usaremos la opción Ver>Ventana Propiedades. Una aplicación de este tipo consta generalmente de una única clase. las aplicaciones de consola representan uno de los tipos de proyecto más sencillos que podemos crear. En el código se hará uso intensivo de la clase System. botones de radio y otros controles de Windows. a continuación. la línea de comandos de texto. El primero está en una ventana oculta en la zona izquierda del entorno. sin recurrir a elementos como las listas. si no queremos usar el propuesto 19 . para poder componer la interfaz de usuario de nuestro primer programa necesitaremos trabajar con algunos elementos más. Opcionalmente podemos introducir un nombre para dicha aplicación en la parte inferior.Tecnologías de la Información y Comunicación ELEMENTOS DE TRABAJO Además de los que ya hay visibles. Los métodos de esta clase son estáticos.

Text.Collections. using System. using System. Las tres primeras líneas hacen referencia a otros tantos espacios de nombres en los que se encuentran las clases más usadas en este tipo de aplicaciones. cuyo nombre es el introducido en la ventana Nuevo proyecto. en cuyo interior hay una 20 . Un clic en el botón Aceptar y el asistente creará el proyecto.Tecnologías de la Información y Comunicación por defecto. A continuación se encuentra la definición de un espacio de nombres propio. namespace AppConsola { class Program { static void Main(string[] args) { } } } Procedemos a crear una aplicación de consola. añadiendo un módulo con el código siguiente: using System.Generic.

Cómo crear aplicaciones con ventanas Cuando un programa está pensado para ser empleado directamente por un usuario. una herramienta que permite al programador arrastrar los componentes hasta el formulario y editar sus propiedades generando automáticamente el código que. será conocer más detalles acerca del propio formulario y también algunos de los controles de uso más habitual. El objetivo de este capítulo.Tecnologías de la Información y Comunicación clase con el método Main. La plataforma . En esta última fase es donde entra en escena el diseñador de formularios integrados en el entorno de Visual C#. Las interfaces gráficas de usuario o GUI (Graphics User Interface) se han convertido en un estándar. menús. y no para ejecutarse como un servicio o aplicación de servidor. en un proceso realmente sencillo y eficiente.NET cuenta con un sofisticado conjunto de componentes dirigidos a facilitar la construcción de este tipo de aplicaciones. conocidos genéricamente como componentes para formularios Windows. simplificando la interacción con las personas a través del uso de metáforas como los botones. con las que se representan conceptos bien conocidos por todos. lo habitual es que cuente con una interfaz basada en ventanas. se tendría que haber escrito manualmente. cuadrículas. las listas o los menús. etc. de tal forma que el programador ya tiene a su disposición los elementos antes citados: botones. gracias al diseñador y los componentes prefabricados. Puede modificar libremente el nombre de la clase. 21 . partiendo de que sabemos cómo arrastrar los componentes desde el Cuadro de herramientas hasta el formulario y modificar sus propiedades en la ventana Propiedades al ser tareas que aprendimos en un capítulo previo. El resultado final es que el diseño de la interfaz de una aplicación basada en formularios Windows se convierte. pero no así el del método Main. sus parámetros o tipo de retorno. configurarlos a través de sus propiedades y métodos y responder a los eventos que generan. Solamente tiene que crear los componentes. de otra manera. listas.

y que sirven para ajustar su tamaño. enumerando las opciones de configuración que se 22 . hacer clic sobre el control y después en el punto del formulario donde se desea colocar o bien hacer clic sobre el control y a continuación arrastrar y soltar sobre el formulario a fin de delimitar el área que deseamos asignar como tamaño inicial. Dicho botón da paso al menú de tareas del control. una vez insertado el control puede arrastrarse y colocarse donde deseemos. haciendo que sea más fácil conseguir controles con el mismo ancho o alto sin necesidad de tener que editar directamente las propiedades Width y Height en la ventana Propiedades. para alterar su posición. Forman parte de este grupo los botones. si bien podemos ajustarlas con posterioridad. botones de radio y etiquetas de texto. también la posición inicial en el formulario será la usada por defecto por el diseñador. A la hora de insertar un control en el formulario tenemos varias opciones: hacer doble clic sobre el control en el Cuadro de herramientas. También al cambiar el tamaño aparecerán dichas líneas.Tecnologías de la Información y Comunicación Controles más usuales y sus características La lista de controles que pueden utilizarse para confeccionar una interfaz de usuario basada en formularios Windows es muy extensa. una vez insertados. En cualquier caso. A medida que arrastremos los controles dentro del formulario. En general. los controles de uso más común los encontraremos en la sección Controles comunes del Cuadro de herramientas (véase la figura 4. cuadros de texto. ciertos controles mostrarán en la parte superior derecha un botón con el icono de una flecha en su interior. mientras que el segundo procedimiento nos permite ponerlo en el lugar que deseemos. el diseñador nos irá mostrando unas líneas guía que facilitan la alineación respecto a los demás que haya alrededor. Las dos primeras técnicas insertan el control usando las dimensiones por defecto. De optar por el doble clic en el icono del control.1 en la página siguiente). pero existe un grupo cuyo uso resulta mucho más frecuente. listas. Son éstos en los que vamos a concentrarnos en un principio. Además de los recuadros que aparecen en el contorno del control. entre otros.

tienen un ascendiente común: la clase Control definida en 23 . como tales.Tecnologías de la Información y Comunicación utilizan de forma más habitual en cada caso. por ejemplo. un recuadro de texto y una lista. permite activar o desactivar la propiedad MultiLine para permitir la introducción de varias líneas de texto. La lista de tareas de un TextBox. Propiedades. lo cierto es que todos ellos son controles Windows y. Controles de uso común. métodos y eventos comunes A pesar de las patentes diferencias que existen entre un botón. mientras que en el control ListBox encontramos opciones para editar los elementos mostrados en la lista o vincularla a un origen de datos.

el ancho y alto. a los que se añaden otros de carácter específico. Width y Height: Estas cuatro propiedades contienen las coordenadas de la esquina superior izquierda del control (columna y fila). Esta estructura dispone de métodos que facilitan el movimiento del control.Tecnologías de la Información y Comunicación System. Width y Height. respectivamente. Top. con independencia de los controles concretos que vayamos a usar. • Location: Es una estructura de tipo Point que contiene las coordenadas (X e Y) donde está colocado el control. Aunque normalmente se establecen en la fase de diseño mediante operaciones de arrastrar y soltar.Windows. Al igual que la anterior cuenta con métodos para manipular posición y tamaño. por lo que representa una vía de acceso las coordenadas y dimensiones del control. Todos los controles se colocan en el interior de un contenedor. • Bounds: Esta propiedad también es una estructura. 24 . Heredados de la clase Control disponen de los siguientes elementos: • Left.Forms. Esto explica que compartan un mismo conjunto de miembros. normalmente un formulario Windows. El conocimiento de los miembros comunes. Basta con entregar la lista de parámetros adecuada: coordenadas de la esquina superior izquierda a SetLocation y coordenadas y dimensiones a SetBounds. entre ellos una serie de propiedades y eventos comunes. por tanto. • SetLocation y SetBounds: Mediante estos dos métodos puede fijarse la posición o la posición y dimensiones en un solo paso. Y. pero en este caso de tipo Rectangle y tiene cuatro miembros: X. por lo que necesitan por igual contar con unas coordenadas y unas dimensiones. sin necesidad de realizar varias asignaciones a las propiedades antes citadas. podemos editar directamente cualquiera de estas propiedades tanto en la ventana Propiedades como a través de una sentencia de asignación en el código del programa. nos será de utilidad general.

siendo el más habitual el uso de la tecla Tab para ir avanzando según un orden preestablecido. 25 . También puede otorgarse de forma directa a un cierto control haciendo clic sobre él con el puntero del ratón.Tecnologías de la Información y Comunicación Muchos de los controles de una interfaz basada en ventanas pueden tomar el foco de entrada. El foco de entrada puede desplazarse de un control a otro. estado en el cual las pulsaciones de teclado van dirigida a ese control y no a los demás que hubiese en la ventana.

Las reglas son las siguientes: 1. 3. No debe de llevar caracteres especiales. ya sea una clase. etc. 26 . El primer carácter debe de empezar con letra o con el carácter subrayado _. un método. Es sensible a mayúsculas. 5. No debe de llevar espacios. No usar palabras reservadas.Tecnologías de la Información y Comunicación UNIDAD III IDENTIFICADORES Y TIPOS DE DATO Variables o identificadores Una variable puede verse simplemente como un hueco en el que se puede almacenar un objeto de un determinado tipo al que se le da un cierto nombre. un nombre con el que identificaremos algún elemento de nuestro código. en C# un identificador no es más que. Para poderla utilizar sólo hay que definirla indicando cual será su nombre y cuál será el tipo de datos que podrá almacenar. como su propio nombre indica. Ejemplos: A //valido a //valido la variable (a) es diferente a la variable (A) var1 //valido 1var //No valido inicia con número _1var // valido Var1 real //no valido contiene un espacio while //no valida es palabra reservada. lo que se hace siguiendo la sintaxis: Tipo_ de_ Dato nombre_de_variable. una variable. 4. Al igual que en cualquier lenguaje de programación. 2.

Tecnologías de la Información y Comunicación 23+321 //no valida contiene un carácter especial (+).147. false [‘\u0000’. float flotante. ‘\uFFFF’] [5. si tú deseas guardar caracteres (“ABC!”#”).7×10308] Ejemplos de declaración de variables: string cad. char carac. tiene que ser en uno de caracteres. Tipos de Datos Los tipos de datos se puede decir que son como contenedores donde tú colocas valores.648 .4×1038] true.3. bool log. si podrás guardarlo en un contendor de número pero antes tienes que hacer una conversión. esto lo veremos más adelante.5×10-45 . // Guardar un Carácter log=true.147. int num. // Guarda un verdadero 27 . En seguida se muestra una tabla con los tipos de datos más comunes: Tipo de Dato string int float bool char double Bits Variable 32 32 1 16 64 Rango de Valores El permitido por la memoria [-2.1. // Guardar números con punto decimal carac='6'.34. Pero si quieres guardar caracteres que son números (“45”). Guardar datos en una variable: cad="aquí se guarda una cadena".483. num=53.647] [1. //Guardar números Enteros flotante =14. no lo puedes guardar en un contenedor de números. 2.0×10-324 .483.

Console.WriteLine(). Console.WriteLine("Este es la primera parte"). Console. ent=44. int ent.Write( Mensaje).Write("Este es la primera parte").34. Console. dato=12. Salida: El dato Flotante es: 12. ent=44. Método para Mostrar Dato en Pantalla Console. Console.34 El dato Entero es: 44 float dato. Console. Esta es una de las clases principales en aplicaciones de Consola.WriteLine("El dato Entero es :"+ent). dato=12.WriteLine("El dato Flotante es :"+dato). Console. //Muestra un mensaje en pantalla y no salta de línea.Write("Este es la segunda parte"). Contiene 3 de los principales Métodos: • • • Console. 28 .WriteLine("Este es la segunda parte").34.Write().Tecnologías de la Información y Comunicación CLASE CONSOLE. //Muestra un mensaje en pantalla y salta de línea.ReadLine(). int ent. Salida: Este es la primera parte Este es la segunda parte Console.WriteLine(Mensaje). Salida: Este es la primera parte Este es la segunda parte Mostrar un mensaje y el valor de las variables float dato. Console.

/* {0} = dato {1} = ent {2} = 65/23 */ Salida: El dato Flotante es: 12.ReadLine()).ReadLine(). // Declaración de variable variable = Console. dato. // Este método devuelve una cadena Ejemplo: Si queremos leer el dato “45” introducido por teclado. Mandamos llamar el método ReadlLine () para leer el Dato.65/23). lado // este método lee el “45” pero no se guarda en ningún Ahora si queremos guardarlo el valor string (“45”) en una Variable string variable.34 Dato Entero es: 44 Dato de no variable: 2.WriteLine (“El dato Flotante es :{0} Dato Entero es:{1} Dato de no variable:{2}". Como son diferentes tipos se tiene que hacer los siguientes pasos: // num fue previamente declarado como un atributo entero string variable.82 Leer datos del Teclado Para ello utilizaremos el método ReadLine() de la clase Console. Ahora queremos guardarlo el valor “45” en una Variable (Entera).ReadLine(). y pulse la tecla ENTER.Tecnologías de la Información y Comunicación Console. ent. Console.ToInt32(Console. que espera a que el usuario teclee algo. // Se ejecuta el método ReadLine() y regresa el valor “45” que se guarda en una variable. // Convierte variable (string) en num (int) Otra forma de hacer esto sería la siguiente: // num fue previamente declarado como un atributo entero num = Convert. // Convierte variable (string) en num (int) 29 .ReadLine().ToInt32(variable).ReadLine(). // Declaración de variable variable = Console. como son del mismo tipo no es necesario convertilo a ningún tipo. Console. // Variable contiene el 45 num = Convert.

al igual que el resto de las entidades dentro de un programa. Estos valores pueden surgir como resultado de efectuar operaciones. Este tipo indicará la forma en que podremos manipular la expresión. tienen asociado un tipo de datos. en cuáles variables podremos almacenar su valor.ToBool(variable) // Convierte a Boleano Convert.ToInt32(variable) // Convierte a Entero de 32 bits Convert. entero=Convert. int entero.ToDouble(variable) // Convierte a Double (flotante de 64 bits) Convert. 30 . al extraerlos de las variables. st="45".ToInt32(st). por ejemplo. EXPRESIONES Se conocen como expresiones los valores que son manipulados dentro de un programa.ToSingle(variable) // Convierte a float Convert.ToString(variable) // Convierte a Cadena Ejemplo: string st.Tecnologías de la Información y Comunicación CLASE CONVERT Esta clase sirve para convertir un tipo de dato a otro tipo de dato. Las expresiones. o simplemente pueden ser constantes expresadas directamente dentro del código del programa. //también puede ser de la siguiente forma entero=Convert. como valores de retorno de las funciones.ToInt32("45"). Por ejemplo una cadena a un entero en seguida se muestra algunos de los principales métodos: Convert.ToChar(variable) // Convierte a Char Convert. todos estos métodos regresan el valor de tipo que se indique en el método.

Pueden ser constantes. de tipos enteros o reales. por ejemplo. contenidos de variables numéricas. operadores aritméticos para construir expresiones numéricas. Tenemos.-(unitario) */% +- Ejemplos de expresiones aritméticas: 2 + 3 * 2 * tiene precedencia sobre + (Resultado: 8) (2 + 3) * 2 los paréntesis alteran la precedencia (Resultado: 10) -2 / x si x vale cero se producirá un error de ejecución x++ notación postfija (retorna el valor antes del incremento) ++x notación prefija (retorna el valor después del incremento) 2 .Tecnologías de la Información y Comunicación Existe un conjunto de operadores para cada tipo de datos. resultados de operaciones aritméticas como sumas o multiplicaciones.Decremento Precedencia: ++ -.1 + 3 asociación por la izquierda: 4 31 .Signo negativo ++ Incremento -. Operadores binarios: + * / % Suma Resta Multiplicación División Módulo (sólo sobre tipos de números enteros) Operadores unitarios: . o combinaciones de las anteriores unidas mediante operadores aritméticos. y operadores lógicos para construir expresiones booleanas. Expresiones Aritméticas Las expresiones aritméticas son valores numéricos. de manera que siempre es posible construir una nueva expresión a partir de una o varias ya existentes.

== != < <= > >= igual distinto menor menor o igual mayor mayor o igual Precedencia: La precedencia está establecida por el siguiente orden de evaluación. || OR (hace la disyunción lógica de dos valores bool). Operadores unitarios: ! NOT lógico Operadores relacionales o de comparación: Este tipo de operadores permite comparar el valor de dos expresiones de cualquier tipo.Tecnologías de la Información y Comunicación 15 % 6 operador módulo o residuo (Resultado: 3) -x le cambia el signo al contenido de x 3 * 4 % 5 igual precedencia. (Retorna: 2) 3 * (4 % 5) los paréntesis alteran la precedencia (Retorna: 12) 1 + 15 % 6 % tiene precedencia mayor (Retorna: 4) Expresiones Relacionales. La asociación se aplica de izquierda a derecha. En C# se conoce el tipo booleano como bool. para operadores con igual precedencia. Operadores binarios: && AND (hace la conjunción lógica de dos valores bool). 32 . pero asociativa a izq. Lógicas o Booleanas Este tipo de valores se emplea para dirigir al programa por un determinado flujo de ejecución dependiendo de la evaluación a verdadero o falso de una expresión lógica. devolviendo como resultado un valor booleano (entero).

4>= 2 Retorna Verdadero. no importa lo que sea x. !x Verdadero cuando el contenido de la variable x es false. (x > 5) && !y Verdadero cuando el contenido de la variable x es mayor que 5. que requiere que su primer operando (el del lado izquierdo) sea una variable. false Falso siempre. true || x Verdadero siempre. 5 == 6 retorna Falso. el resultado de esta operación es que el valor expresado se almacenará en la variable especificada al lado izquierdo. Es un operador binario. no importa lo que sea x. o una expresión en general. y el contenido de y es false.Tecnologías de la Información y Comunicación < <= >= > == != && || Ejemplos de expresiones booleanas: x Verdadero cuando el contenido de la variable x es true. (x==1) Verdadero si el valor de la variable x es 1. un valor constante. general de este En caso de que el valor asignado sea una constante. ((4 % 2 == 0) || (4 % 3 == 0)) && false Operador de Asignación El operador de asignación ( = ) permite almacenar datos en las variables. false && x Falso siempre. 33 . true Verdadero siempre. El segundo operando (el del lado derecho) puede ser otra variable. La sintaxis operador es la siguiente: <variable> = <expresion> .

} else { <Sentencias2>.Tecnologías de la Información y Comunicación SENTENCIAS DE CONTROL Sentencia if El if evalúa una expresión booleana (condición) y regresa un valor (verdadero o falso). Sintaxis: if(<condición>) { <Sentencias1>.WriteLine(" la clave es correcta ").equal(clave)) { Console. clave=”clave”. } Salida: 10 es Mayor a 5 34 . si no ejecuta las sentecias2. } Salida: 10 es Mayor a 5 Ejemplo con operadores: string usu=”usuario”.equal(usu) && clave. } else { Console. b=5.WriteLine(" La clave es incorrecta "). Si es verdadero ejecuta las sentencias1. } Ejemplo: int a=10. if(a>b) { Console.WriteLine(a+" es Menor a "+b). } else { Console.WriteLine(a+" es Mayor a "+b). if(usu.

WriteLine("Opción 2"). default: Console. case 3: Console. } Salida: Opción 3 Sentencia While La instrucción while permite ejecutar un bloque de sentencias mientras sea verdadera la condición. break. . case <valor 2>: <Sentencias>. break. break. break. .WriteLine("Opción 3"). break. . break. Su sintaxis de uso es: 35 .WriteLine("Opción 1"). default: <Sentencias>.WriteLine("No seleccionaste ninguna"). } // El break se utiliza para terminar con el switch Ejemplo: int a. case <valor n>: <Sentencias>. break.Tecnologías de la Información y Comunicación Opción Múltiple o Expresiones Multivaluadas: switch Nos permite decidir entre diferentes opciones (bloques de sentencias) a ejecutar según el valor de una expresión. a = 3. break. switch (a) { case 1: Console. case 2: Console. Sintaxis: switch ( <expresión> ) { case <valor 1>: <Sentencias>.

Write(c + " ").... En realidad <sentencias> puede ser una única instrucción o un bloque de sentencias. con la única diferencia de que Do.. que ha de producir un valor lógico.while respecto al de while es que en vez de evaluar primero la condición y ejecutar <sentencias> sólo si es cierta. La única diferencia del significado de do.. while (c < 10) { Console.. c++. Cuando sea falsa (false) se pasará a ejecutar la instrucción siguiente al while.. Si es cierta (valor lógico true) se ejecutan las <sentencias> y se repite el proceso de evaluación de <condición> y ejecución de <sentencias> hasta que deje de serlo.while es una variante del while. } Salida: 0 1 2 3 4 5 6 7 8 9 Sentencia Instrucción do.while primero ejecuta las <sentencias> y luego mira la <condición> para ver si se ha de repetir la ejecución de las mismas.while La instrucción do. do..while por lo menos se ejecuta una sola vez. Ejemplo: 36 . // incrementa c de 1 en 1. int c = 0. Sintaxis: do { <sentencias> } while(<condición>).Tecnologías de la Información y Comunicación while (<condición>) { <sentencias> } Su significado es el siguiente: Se evalúa la <condición> indicada..

c++) { Console. que suelen usarse para definir e inicializar variables que luego se usarán en <sentencias>. Sintaxis: for (<inicialización>.Write(c + " "). Ejemplo: int c. <modificación>) { <sentencias>. } while (i < 5). Salida: 0 1 2 3 4 Sentencia for La sentencia for es una variante de while que permite reducir el código necesario para escribir los tipos de bucles más comúnmente usados en programación.Tecnologías de la Información y Comunicación int i = 0. <condición>. mientras que si es cierta se ejecutan las <sentencias> indicadas. } Salida: 0 1 2 3 4 5 6 7 8 9 37 . Luego se evalúa <condición>. do { Console. luego se ejecutan las sentencias de <modificación> -que como su nombre indica suelen usarse para modificar los valores de variables que se usen en <sentencias>.Write(i + " "). for (c = 0. } El significado de esta instrucción es el siguiente: se ejecutan las sentencias de <inicialización>. Se utiliza cuando se conoce el número de interacciones o cuando se requiere un contador. y si es falsa se continúa ejecutando por la instrucción siguiente al for. i++. c < 10.y luego se reevalúa <condición> repitiéndose el proceso hasta que ésta última deje de ser cierta.

namespace <nombreEspacio> { <tipos o clases> } CLASES Una clase es la definición de las características concretas de un determinado tipo de objetos. class <nombreClase> { <atributos o campos> <métodos> } Campos Un campo es un dato común a todos los objetos de una determinada clase. Por otro lado. se suele decir que el tipo de dato de un objeto es la clase que define las características del mismo. Para definir cuáles son los campos de los que una clase dispone se usa la siguiente sintaxis dentro de la zona señalada como <atributos> en la definición de la misma: 38 . los espacios de nombres también permiten poder usar en un mismo programa varias clases con igual nombre si pertenecen a espacios diferentes. Por esta razón. de cuáles son los datos y los métodos de los que van a disponer todos los objetos de ese tipo. La idea es que cada fabricante defina sus tipos dentro de un espacio de nombres propio para que así no haya conflictos si varios fabricantes definen clases con el mismo nombre y se quieren usar a la vez en un mismo programa. Es decir.Tecnologías de la Información y Comunicación CREACIÓN DE CLASES Namespace Concepto de espacio de nombres del mismo modo que los ficheros se organizan en directorios. los tipos de datos se organizan en espacio de nombres.

// métodos } Para acceder a un campo de un determinado objeto se usa la sintaxis: <objeto>. por lo que como al principio del 39 .<campo> Ejemplo para un objeto llamado obj: obj. y en <tipoDato> hemos de indicar cuál es el tipo de dato del objeto que vamos a crear. El <encapsulamiento> es el tipo de ocultamiento de los datos los principales son: public. Ejemplo: class datospersonales { // atributos o campos public string nombre.Tecnologías de la Información y Comunicación <encapsulamiento> <tipoDato> <nombreCampo>. Métodos Un método es un conjunto de sentencias a las que se les asocia un nombre de modo que si se desea ejecutarlas basta referenciarlas a través de dicho nombre en vez de tener que escribirlas. protected char caracter. Dentro de estas sentencias es posible acceder con total libertad a la información almacenada en los campos pertenecientes a la clase dentro de la que el método se ha definido. Los campos de un objeto son a su vez objetos. El nombre que demos al campo puede ser cualquier identificador que queramos siempre y cuando siga las reglas para la escritura de identificadores y no coincida con el nombre de ningún otro miembro previamente definido en la definición de clase. private int edad.nombre=”Un Nombre”. prívate y protected.

protected char caracter. y el tipo de dato al que pertenece este objeto es lo que se indica en <tipoDatoDevuelto>. // metodos public void Cumpleaños() { Edad++. prívate y protected. La sintaxis que se usa en C# para definir los métodos es la siguiente: <encapsulamiento> <tipoDatoDevuelto> <nombreMétodo> (<parametros>) { <sentencias> } El <encapsulamiento> es el tipo de ocultamiento de los datos los principales son: public. private int edad. // Incrementa en uno de la edad del clase 40 . los métodos permiten manipular los datos almacenados en los objetos. Si no devuelve nada se indica void. En <parametros> se indica es cuáles son los tipos de dato de estos objetos y cuál es el nombre con el que harán referencia las instrucciones del método a cada uno de ellos. Aunque los objetos que puede recibir el método pueden ser diferentes cada vez que se solicite su ejecución. siempre han de ser de los mismos tipos y han de seguir el orden establecido en <parametros>. y si devuelve algo es obligatorio finalizar la ejecución de sus sentencias con alguna instrucción return <objeto>. que indique qué objeto ha de devolverse.Tecnologías de la Información y Comunicación tema se indicó. Ejemplos: <encapsulamiento> public <tipoDatoDevuelto> void <nombreMétodo> (<parametros>) mostraramigos (string nombreamigo) class datospersonales { //atributos o campos public string nombre. Todo método puede devolver un objeto como resultado de la ejecución de las sentencias que lo forman.

se escribe: <nombreobjeto>.Tecnologías de la Información y Comunicación } public string regresarnombre() // MEtodo que regresa un dato { return nombre. str = p. Por ejemplo. Como es lógico. } } La sintaxis usada para llamar a los métodos de un objeto es la misma que la usada para llamar a sus campos. // este metodo regresa una cadena y la guarda en str // Este método tiene parámetros de entrada p. si el método no tomase parámetros se dejarían vacíos los parámetros en la llamada al mismo.regresanombre().<nombremétodo>(<parámetros>). O sea. int edadamigo) { Console. sólo que ahora tras el nombre del método al que se desea llamar hay que indicar entre paréntesis cuáles son los valores que se desea dar a los parámetros del método al hacer la llamada. } // método con parámetros de entrada public void mostraramigos(string nombreamigo.mostraramigo(“Joel”.20). Salida: Joel de 20 años es amigo de Luis 41 . // método que no regresa nada // este método regresa una cadena que se puede guardar en cualquier variable de tipo cadena string str. para llamar al método Cumpleaños() de un objeto Persona llamado p se haría: p.WriteLine(nombreamigo + " de " + edadamigo + " años es amigo de " + nombre).Cumpleaños().

pero si tu agregas un constructor con parámetros ya no podrás usar el constructor vacio al menos que lo agregues. por lo que no tiene sentido incluir en su definición un campo <tipoDevuelto> y el compilador considera erróneo hacerlo (aunque se indique void) Ejemplo utilizando la clase anterior: datospersonales dat = new datospersonales(). devolviendo una referencia al objeto recién creado. Como new siempre devuelve una referencia a la dirección de memoria donde se cree el objeto y los constructores sólo pueden usarse como operandos de new. no tiene sentido que un constructor devuelva objetos. es decir tu puedes colocar o no el constructor. Este operador crea un nuevo objeto del tipo cuyo nombre se le indica y llama durante su proceso de creación al constructor del mismo apropiado según los valores que se le pasen en <parametros>. pero si puede tener parámetros de entrada. // Crear un objeto de la clase datos Una clase puede contener n constructores. por tal motivo no se coloca ningún TipoDatoDevuelto como en los métodos.Tecnologías de la Información y Comunicación OBJETO Ahora que ya sabemos cómo definir las clases de objetos que podremos usar en nuestras aplicaciones ha llegado el momento de explicar cómo crear objetos de una determinada clase y la sintaxis es: <nombreClase> <nombreobjeto>= new <nombreClase>(<parametros>). Hay que resaltar el hecho de que new no devuelve el propio objeto creado. El constructor de un objeto no es más que un método definido en la definición de su tipo que tiene el mismo nombre que la clase a la que pertenece el objeto y no tiene valor de retorno. sino una referencia a la dirección de memoria dinámica donde en realidad se ha creado. Las clases toman como default un constructor vacio. Un constructor no regresa ningún dato. 42 . esto depende de las necesidades que tenga nuestra aplicación.

Datospersonales ob=new Datospersonales(“Nombre”. La sintaxis es la siguiente: static void Main(string[] args) { Sentencias. } 43 . // Constructor con parametros MÉTODO MAIN Main es el método principal. además del método Main. Se puede crear una clase que solo contenga este método.23).Tecnologías de la Información y Comunicación Sintaxis: class <nombreclase> { //atributos o campos public nombreclase () // Constructor Vacio { } public nombreclase (string d1. int d2. objeto d3 ) { } // métodos } Creamos un objeto que se llama ob: Datospersonales ob=new Datospersonales(). es el primer método que busca la aplicación para ejecutar solo puede existir uno en un proyecto. Nota: Nunca Borrar este método. o puede estar dentro de una clase que contenga atributos y otros métodos.

. public void Cumpleaños() // Incrementa en uno de la edad del clase { Edad++. } */ Vamos a crear un ejemplo aplicando todo lo que se vio en este documento: 1. Damos clic en el menú Archivo-NuevoProyecto. seleccionamos aplicación de consola y le damos un nombre al proyecto y seleccionamos la ubicación del proyecto dándole clic en el botón Examinar. Para colocar comentarios en una sola línea se utiliza // esto puede ir al inicio de una línea sin código o puede ir al final de una sentencia.Creamos un proyecto de tipo Consola.Tecnologías de la Información y Comunicación COMENTARIOS Para escribir comentarios en una aplicación existen dos formas un es para colocar comentarios en una línea y la otra forma es colocar comentarios en bloques. /* Este es un bloque de comentario sin código Esta es otra línea con comentarios */ /* Es es un ejemplo de codigo como comentario la apliación no toma en cuenta este código. } public string regresarnombre() // MEtodo que regresa un dato { return nombre. es decir aunque tenga código si esta dentro de estos símbolos serán comentarios. 44 . Ejemplo: // Este es un comentario sin código public nombreclase () // Constructor Vacio La otra forma es en bloques inicia con /* y termina con */ todo lo que coloquemos en estos símbolos serán comentarios.

Tecnologías de la Información y Comunicación

Tenemos la clase Program, esta clase que contiene el método principal Main, aquí es donde inicia nuestra aplicación.

2.- Para crear otro archivo con otra clase nos vamos al siguiente menú ProyectoAgregar Clase y le damos un nombre a nuestra clase

45

Tecnologías de la Información y Comunicación

Y aparece un archivo que contiene la nueva clase.

3.- Escribimos el código en nuestra clase datos
using System; using System.Collections.Generic; using System.Text; namespace datospersonales { class datos { //atributos o campos public string nombre; private int edad;

46

Tecnologías de la Información y Comunicación

// Constructores public datos() { edad = 1; } public datos(string nom,int ed) { nombre = nom; edad = ed; }

// metodos // datos para leer datos public void leerdatos() clase {

// Incrementa en uno de la edad del

Console.Write("Dame tu nombre:"); nombre = Console.ReadLine(); Console.Write("Dame tu Edad:"); edad= Convert.ToInt32( Console.ReadLine() ); } public void Cumpleaños() clase { edad++; Console.WriteLine(nombre + " cumplio años ahora tiene " + edad + " años"); } public string regresarnombre() { return nombre; } // Metodo que regresa un dato // Incrementa en uno de la edad del

// método con parámetros de entrada public void mostraramigos(string nombreamigo, int edadamigo) { Console.WriteLine(nombreamigo + " de " + edadamigo + " años es amigo de " + nombre); } } }

4.- Agregar el siguiente Código en la clase Program
using System; using System.Collections.Generic; using System.Text; namespace datospersonales { class Program

47

19). datos uriel = new datos("Uriel".WriteLine().Cumpleaños().WriteLine().WriteLine("El metodo Regresarnombre Regreso: " + dat. 16). Console. Console. uriel. // Mandamos llamar el metodo Cumpleaños uriel.Tecnologías de la Información y Comunicación { static void Main(string[] args) { datos dat = new datos().WriteLine(). 16). 19). Console.WriteLine("El metodo Regresarnombre Regreso: " + alin. datos alin = new datos("alin". Console.mostraramigos("Jesus". // Mandamos llamar el metodo Cumpleaños /* Mandamos llamar el metodo mostraramigos el cual pide dos * parametros de entrada una cadena y un entero * */ dat. alin.Cumpleaños(). 16). Console.ReadLine().regresarnombre()).WriteLine().leerdatos().WriteLine(). Console. // Mandar llamar el metodo leerdatos() // Mandamos llamar el metodo regresarnombre y dos devuelve un dat tipo cadena Console.mostraramigos("Jesus".Cumpleaños().regresarnombre()). Console. dat. // Crear un objeto de la clase datos dat. // Mandamos llamar el metodo Cumpleaños alin.mostraramigos("Jesus".WriteLine(). Console. } } } Salida de la aplicación: 48 .

.Tecnologías de la Información y Comunicación EJERCICIOS 1.Hacer un programa con una clase que pida datos de un empleado como son nombre. 4. 5. RFC. Muestre todos los datos del empleado y su sueldo normal y su sueldo con la compensación... 3. sueldo y tipo empleado. Además calcule el sueldo total. Que muestre cada digito que va obteniendo.. división o resta de 2 números y muestre el resultado. RFC y sueldo y muestre los datos..Crear un programa con una clase que multiplique 2 números y muestre el resultado. multiplicación. 49 . si es supervisor tiene una compensación del 20% y si es obrero tiene el 10% mas del sueldo normal.Crear un programa con una clase que me haga una operación de suma. 2.Hacer un programa con una clase que pida datos y muestre de un empleado como son nombre. si es gerente tiene un compensación de 50% mas del sueldo normal.Hacer un programa que convierta de números decimales a binarios.

capturar sus elementos. la primera localidad es 0 y la ultima es el tamaño menos 1. int temp17. Un vector es una porción de memoria que es utilizada para almacenar un grupo de elementos del mismo tipo y se diferencian en el índice. Pero ¿qué quiere decir esto y para qué lo queremos? Pues bien.temp4.temp6. También reciben el nombre de vectores en álgebra o arreglos unidimensionales en programación.temp14. 50 .temp21.temp3. etc.temp5. realizar operaciones con ellos. Para darle cierta utilidad al final calcularemos la media de las temperaturas.temp11.temp12.temp13. desplegarlos.temp22. desplegarlos.temp20. supongamos que somos un meteorólogo y queremos guardar en el ordenador la temperatura que ha hecho cada hora del día.temp23.temp9. por lo que el tipo del arreglo.temp18. Con lo que sabemos hasta ahora sería algo así (que nadie se moleste ni en probarlo): class { int temp1.temp8 . Los procesos normales con una lista o con sus elementos.temp15. int temp10. todas las variables contenidas en el arreglo son referidos como elementos los cuales deben ser del mismo tipo. Los vectores empiezan desde la localidad 0.temp2. incluyen declarar toda la lista.temp7. temp16. Un arreglo tipo lista se define como una variable que permite almacenar un conjunto de datos del mismo tipo organizados en una sola columna y uno o mas renglones.Tecnologías de la Información y Comunicación UNIDAD IV ARREGLO TIPO LISTA (UNIDIMESIONALES) Un arreglo contiene variables a las cuales se accede a través de índices.temp19.

Write("Dame una temperatura:"). } public void promedio() { promedio=(temp1+temp2+…+temp23)/23. Console.Write("Dame una temperatura:").Write("Dame una temperatura:"). Hasta ahora sólo conocemos los tipos básicos de datos. } } Declaración de Vectores Sintaxis de un vector: Tipo_ de_dato[ ] nombre_del_vector=new Tipo_ de_dato[ dimension]. double.ReadLine()).ReadLine()).ToInt32(Console. clase.ToInt32(Console. Tipo_ de dato: Es el tipo de datos que contendrá la matriz. char. public void leer() { Console. Por ejemplo declarar un vector tipo cadena: string[] nombre = new string [ 20 ].ReadLine()). Tipo_ de_dato[ ] nombre_del_vector=new Tipo_ de_dato[ dimension]. temp3=Convert. etc. float. [dimension]: Indica el número de elementos de tipo tipo_de_datos contendrá la matriz identificador. temp2=Convert.ToInt32(Console. Posteriormente veremos cómo definir nuestros propios tipos de datos.Write("Dame una temperatura:"). nombre_del_vector: Es el nombre que le damos a la variable tipo vector y por el cual la referenciaremos en nuestro programa. temp1=Convert. … Console. Console.ReadLine()).Tecnologías de la Información y Comunicación int promedio.ToInt32(Console. int. 51 . temp23=Convert.

string. indentificador y expresión correspondiente a la colección. Cuando utilizas solamente el nombre del vector los atributos.metodos y eventos son de un arreglo. clase. Para mandar llamar un objeto de un arreglo necesitas utilizar un indice el cual nos indica la localidad donde esta almacenado el objeto. Foreach La Sentencia foreach es un comando que lee cada elemento de un colección (arreglo). Identificador: es un nombre para el objeto creado.Tecnologías de la Información y Comunicación Crear Arreglo de Objetos El valor inicial de cada elemento (objeto) de un arreglo es null. un arreglo de objetos es creado utilizando new. Para declarar un objeto de declara de la siguiente manera miclase[] vectorarreglo = new miclase[20]. etc. foreach(Tipo indentificador in colección){ } La variable de iteración es declarada por el Tipo. Tipo: puede ser un int. Una vez que se declara el vector de objetos necesitas inicializar cada objeto del arreglo. Colección: es el arreglo del cual se va a leer cada elemento. La variable de iteración representa el elemento de la colección para cada iteración. 52 . vectorarreglo[indice].mimetodo(). Ejemplo: vectorarreglo[indice] = new miclase().

i < 10. El ref significa que va entra el arreglo y se va a regresar modificado. Como se recuerda anteriormente cuando entra una variable a un metodo aunque se cambiara dentro del metodo el valor con el que entraba seguia siendo el inicial. } } public void imprimir() {// hacemos un recorrido al arreglo para mostrar los datos for (int i = 0.Resize(ref miarreglo.Write("Dame un Valor:"). Ejemplo: miarreglo. Array. public void leerdatos() { // guardamos un elemento en cada localidad de arreglo for (int i = 0.Length Existe un metodo llamdo Resize que se utiliza para cambiar el tamaño del arreglo en caso de que sea necesario. i++) 53 .ReadLine(). para poder obtener la longitud de un array se usa la propiedad Length. i++) { Console. i < 10. En seguida se muestran algunos aplicaciones de ejemplos: Esta aplicación leer 10 numeros y muestra 10: class arreglo { // declarar una arreglo de string string[] a = new string[10]. Pero cuando utilizas ref entra la entidad y si es modificada se regresa modificada. Por ejemplo.Tecnologías de la Información y Comunicación Clase Array La clase Array proporciona muchos métodos y propiedades para manipular arrays. tamaño). Se puede utilizar las propiedades y otros miembros que tiene esta clase para manupular los arrays. a[i]=Console.

int[] califiaciones=new int[5]. nombre = Console.Write("Dame el califiacion: ").ReadKey(). Console. public void leerdatos() { Console.ReadLine()). int n. grupo).Length. Console.ToInt16(Console. a[i]).Tecnologías de la Información y Comunicación Console. } } public void mostrar() { Console. Console. // se muestran las calificacion con el foreach foreach (int cal in califiaciones) { Console.imprimir(). for (int j = 0. } } class Program { static void Main(string[] args) { arreglo ej = new arreglo(). califiaciones[j] = Convert. } } Crear un arreglo de objetos donde guardes las calificaciones y los datos de n alumnos: class alumnos { string nombre. nombre.ReadLine(). ej. 54 . grupo= Console. i. j < califiaciones.Write("Dame el numero de alumnos:").WriteLine(cal).WriteLine("a{0}={1}".Write("Dame el grupo y seccion: ").leerdatos(). ej.WriteLine("{0} del grupo {1} ".ReadLine(). j++) { Console. string grupo.Write("Dame el nombre: "). } } } class Program { static void Main(string[] args) { // Arreglo de alumnos alumnos[] nombre = new alumnos[0].

mostrar().WriteLine(). // Arreglo de alumnos alumnos[] miarreglo = new alumnos[0]. } Console. } } EJERCICIOS 1. i < nombre.ReadLine()).Tecnologías de la Información y Comunicación // Guarda el numero de alumnos n = Convert. } Console.ToInt16(Console. // Utiliza un for para pedir el numero de objetos for (int i = 0.mostrar(). Console. Array.WriteLine().WriteLine(). tamaño). // pide un numero para mostrar los datos de un localidad en especifico int na = Convert. 2. si es supervisor tiene una compensación del 20% y si es obrero tiene el 10% más del sueldo normal. Console.leerdatos().Resize(ref miarreglo.Write("Dame el numero del alumno").Hacer un programa con una clase que pida nombre. Muestre todos los datos de todos empleados y su sueldo normal y su sueldo con la compensación.ReadKey().ToInt16( Console. n). sueldo y tipo empleado.ReadLine()). si es gerente tiene un compensación de 50% más del sueldo normal.Hacer un programa con una clase que pida datos de un 10 empleado como son nombre. // hace un recorrido de arreglo nombre y se guarda cada elemento en val foreach (alumnos val in nombre) { val. RFC.Length. // Manda llamar el metodo leerdatos() nombre[i].Resize(ref nombre. Console. 55 . i++) { // Inicializar el objeto nombre[i] = new datospersonales(). // Muestra los datos del objeto n-1 nombre[na-1]. Además calcule el sueldo total. RFC y sueldo de 10 empleados y muestre los datos de cada empleado. // Cambia el Tamaño del arreglo Array.

Hacer un programa que pida n producto con los siguientes datos clave.Tecnologías de la Información y Comunicación 3. modificar o mostrar los datos del producto. Tenga la opción agregar. 56 . producto y precio..

ejemplo si tu pides un numero y el usuario introduce letras a la hora que quieres utilizar ese numero. el finally es opcional. Es independientemente de que se lance una excepción o no. Para asegurar de que un bloque de se ejecute se utiliza el finally. El try empaquetas el código que se ejecuta en caso de que exista algún error el catch captura el error y tú podrás ejecutar otro código para resolver ese error. no lo puedes hacer porque si tratas de convertirlo a numero va a marcar un error de formato. si no que suceden cuando tu ejecutas el programa. Sintaxis: try { //Sentencias } catch { // Sentencias } Sintaxis para capturar los datos del error. Para resolver estos problemas que nuestro programa termine por un error utilizamos el try y catch que sirve para capturar esas excepciones para evitar que se detenga el programa. Las excepciones son mas los errores que posiblemente puedan suceder que cuando introduce el código no suceden. El catch puede o no llevar un parámetro el cual contiene los datos del error que se cometió. Para mostrar los datos del error cometido utilizamos la propiedad Message del objeto Exception. try { //Sentencias } catch (Exception ex) { // Sentencias } finally { // Sentencias } 57 .Tecnologías de la Información y Comunicación EXCEPCIONES Las excepciones son condiciones de errores que surgen con el flujo normal de código.

// Convierte variable (string) en num (int) Console. // Declaración de variable string variable.WriteLine("El valor introducido no es valido"). } 58 . // Variable contiene el 45 num = Convert. // Declaración de variable variable = Console.ReadLine(). } catch { Console.WriteLine("El dato Entero es :"+num).Tecnologías de la Información y Comunicación Ejemplo: try { int num.ToInt32(variable).

Editorial Waypoint Press. Microsoft Visual C# 2008.NET.. Boutquin P. Marteens Ian (2008).Tecnologías de la Información y Comunicación BIBLIOGRAFÍA Jeff Ferguson. Sharp John (2008). Editoral ANAYA . Gupta M (2003) . La biblia de C#. 59 . INTITUVE C# Introducción a la Plataforma .ISBN: 84-415-1484-4. Sandoval Rodrigo (2004).. Patterson B.. Beere J. Introducción a la Programación Orientada a Objeto en C#.

Tecnologías de la Información y Comunicación 60 .

Sign up to vote on this title
UsefulNot useful