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

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

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

un modelo de programación. parte de ese estado será conocido por los demás y otra parte no. 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 . Dicho esto. con su teoría y su metodología. Un lenguaje orientado a objetos es un lenguaje de programación que permite el diseño de aplicaciones orientadas a objetos. porque “filosofía” sólo hay una y lenguajes muchos. 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. 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. que conviene conocer y estudiar antes de nada.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”.

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. 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 . Esto contrasta con la programación convencional. 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. tanto externos como de otros objetos específicos que se encuentran dentro del sistema. 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.

Una clase es la abstracción que describe propiedades importantes para una aplicación. se dice que el estado interno del objeto (el valor de sus datos) está encapsulado. 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. Los objetos que pertenecen a una clase se describen colectivamente por la definición de una clase. éste no puede ser manipulado directamente desde el exterior y su representación concreta es invisible. Cuando esto se cumple.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. Las operaciones son la única forma para cambiar el estado de los datos. El envío de mensajes es la única forma para que un objeto realice una operación. En lugar de describir los objetos individuales la orientación 3 .

es decir. 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. Clase: Tipo de datos definido por el usuario Objeto: Es un dato del tipo definido por su clase. 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. 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 .

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. o Protegido: sólo se puede acceder a ellos desde dentro de la clase o de las clases heredadas. 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. Un miembro puede ser estático. Tercera: contiene los nombres de los métodos. o Privados: sólo se puede acceder a ellos desde dentro de la clase. Para acceder a propiedades privadas de la clase se definen métodos de acceso.Tecnologías de la Información y Comunicación Segunda: contiene la lista de atributos. cada nombre puede ser seguido por detalles opcionales tales como listas de argumentos y tipos de resultados. ABSTRACCIÓN Y ENCAPSULAMIENTO Dos características fundamentales de la POO 5 . Métodos con los datos de una clase: funciones miembros o métodos de la clase.

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

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

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

tipo u orden de sus argumentos. Sobrecarga: varios métodos se llaman igual. puede ser utilizado a todo tipo de datos compatible. pero difieren en el número. Según la herencia puede clasificarse en Sobreescritura: reemplazar los métodos de la superclase en las subclases. 9 . Así. 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.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.

Sin embargo. 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. Un lenguaje que hubiese sido ideal utilizar para estos menesteres es Java.NET La sintaxis y estructuración de C# es muy parecida a la de C++ o Java. Sus principales creadores son Scott Wiltamuth y Anders Hejlsberg. su sencillez y el alto nivel de productividad son comparables con los de Visual Basic. pero debido a problemas con la empresa creadora del mismo -Sun-.NET. Java o C++ y las 10 . Aunque es posible escribir código para la plataforma . C# es el único que ha sido diseñado específicamente para ser utilizado en ella. Por esta razón. En resumen.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 .NET. éste último también conocido por haber sido el diseñador del lenguaje Turbo Pascal y la herramienta RAD Delphi. se suele decir que C# es el lenguaje nativo de . 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. 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 . C# es un lenguaje de programación que toma las mejores características de lenguajes preexistentes como Visual Basic.NET en muchos otros lenguajes.

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 . como un tipo básico decimal que permita realizar operaciones de alta precisión con reales de 128 bits 11 . 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 . Por ejemplo: El código escrito en C# es auto contenido. pues Microsoft ha escrito la mayor parte de la BCL usándolo. No se incluyen elementos poco útiles de lenguajes como C++ tales como macros. lo que facilita la portabilidad del código. por lo que su compilador es el más depurado y optimizado de los incluidos en el . CARACTERÍSTICAS DE C# Con la idea de que los programadores más experimentados puedan obtener una visión general del lenguaje.Tecnologías de la Información y Comunicación combina en uno solo.) 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.NET. herencia múltiple o la necesidad de un operador diferente del punto (. El hecho de ser relativamente reciente no implica que sea inmaduro.NET en general.NET Framework SDK. 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. sistema operativo o máquina para quienes se compile (no como en C++).

lo que reduce problemas por conflictos de nombres y facilita la legibilidad del código. eventos (asociación controlada de funciones de respuesta a notificaciones) o atributos (información sobre un tipo o sus miembros) 12 . Orientación a objetos: Como todo lenguaje de programación de propósito general actual. herencia y polimorfismo. private y protected. C# soporta todas las características propias del paradigma de programación orientada a objetos: encapsulación.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. la inclusión de una instrucción foreach que permita recorrer colecciones con facilidad y es ampliable a tipos definidos por el usuario. Es decir. En lo referente a la encapsulación es importante señalar que aparte de los típicos modificadores public. Respecto a la herencia -a diferencia de C++ y al igual que Java.Tecnologías de la Información y Comunicación (muy útil en el mundo financiero). 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. De todos modos. esto vuelve a ser más bien una característica propia del CTS que de C#. aunque eso es más bien una característica del CTS que de C#. la sintaxis de C# permite definir cómodamente propiedades (similares a campos de acceso controlado). C# añade un cuarto modificador llamado internal. 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. que puede combinarse con protected e indica que al elemento a cuya definición precede sólo puede accederse desde su mismo ensamblado. 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. C# es un lenguaje orientado a objetos.

Se comprueba que todo acceso a los elementos de una tabla se realice con índices que se encuentren dentro del rango de la misma. • Instrucciones seguras: Para evitar errores muy comunes. 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. 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. finalización de la aplicación o solicitud explícita en el fuente-. y entre un tipo y un tipo hijo suyo del que un objeto del primero almacenase una referencia del segundo (downcasting) Obviamente. por lo que en realidad el CLR y el compilador colaboran para asegurar la corrección de las conversiones. Sin embargo. 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 un tipo y antecesores suyos. Para ello se toman medidas del tipo: Sólo se admiten conversiones entre tipos compatibles. Esto es.Tecnologías de la Información y Comunicación Gestión automática de memoria: Como ya se comentó.NET tiene a su disposición el recolector de basura del CLR. todo lenguaje de . Esto tiene el efecto en el lenguaje de que no es necesario incluir instrucciones de destrucción de objetos. 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. C# también proporciona un mecanismo de liberación de recursos determinista a través de la instrucción using. en C# se han impuesto una serie de restricciones en el uso de las instrucciones de control más 13 . lo último sólo puede comprobarlo en tiempo de ejecución el CLR y no el compilador.

al igual que C++ y a diferencia de Java. Para evitar que esto ocurra. • Extensibilidad de modificadores: C# ofrece. lo que evita la ejecución accidental de casos y facilita su reordenación. tanto para conversiones implícitas como explícitas. • 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. la clase hija dejará de funcionar. 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 . 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. 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. o si introduce un nuevo campo con el mismo nombre que algún método de una clase hija. a través del concepto de atributos. puede usarse como un mecanismo para definir nuevos modificadores. Esto. en C# se toman dos medidas: 14 . que más bien es una característica propia de la plataforma .Tecnologías de la Información y Comunicación comunes. 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.cuando se apliquen a diferentes tipos de objetos. 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.NET . con lo que se evitan errores por confusión del operador de igualdad (==) con el de asignación (=). Por ejemplo. la guarda de toda condición ha de ser una expresión condicional y no aritmética.NET y no de C#.

NET FRAMEWORK. 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++. sino que el CLR también ofrece.net disponible en la página de Microsoft.Tecnologías de la Información y Comunicación • Eficiente: En principio. ya que éstas muchas veces esperan recibir o devuelven punteros. • Compatible: Para facilitar la migración de programadores. lo que puede resultar vital para situaciones donde se necesite una eficiencia y velocidad procesamiento muy grandes. C# no sólo o Java que permite incluir mantiene una sintaxis muy similar a C. en C# todo el código incluye numerosas restricciones para asegurar su seguridad y no permite el uso de punteros. 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. y a diferencia de Java. Nótese que la capacidad de usar punteros en código inseguro permite que se pueda acceder con facilidad a este tipo de funciones. en C# es posible saltarse dichas restricciones manipulando objetos a través de punteros. Sin embargo. la posibilidad de acceder a código nativo escrito como funciones sueltas no orientadas a objetos tales como las DLLs de la API Win32. a través de los llamados Platform Invocation Services (PInvoke). C++ directamente en código escrito en C# fragmentos de código escrito en estos lenguajes. 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. b) EDITOR DE PROGRAMAS 15 .

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

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

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

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

en cuyo interior hay una 20 . añadiendo un módulo con el código siguiente: using System. cuyo nombre es el introducido en la ventana Nuevo 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. using System.Collections. Un clic en el botón Aceptar y el asistente creará el proyecto. using System.Text. namespace AppConsola { class Program { static void Main(string[] args) { } } } Procedemos a crear una aplicación de consola. 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.Generic.

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

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. También al cambiar el tamaño aparecerán dichas líneas. una vez insertado el control puede arrastrarse y colocarse donde deseemos. entre otros. para alterar su posición. Además de los recuadros que aparecen en el contorno del control. listas. De optar por el doble clic en el icono del control.1 en la página siguiente). 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. A la hora de insertar un control en el formulario tenemos varias opciones: hacer doble clic sobre el control en el Cuadro de herramientas. 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. Las dos primeras técnicas insertan el control usando las dimensiones por defecto. Son éstos en los que vamos a concentrarnos en un principio. cuadros de texto. 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. ciertos controles mostrarán en la parte superior derecha un botón con el icono de una flecha en su interior. Forman parte de este grupo los botones. En general. Dicho botón da paso al menú de tareas del control. y que sirven para ajustar su tamaño. En cualquier caso. 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. pero existe un grupo cuyo uso resulta mucho más frecuente. A medida que arrastremos los controles dentro del formulario. una vez insertados. el diseñador nos irá mostrando unas líneas guía que facilitan la alineación respecto a los demás que haya alrededor. enumerando las opciones de configuración que se 22 . mientras que el segundo procedimiento nos permite ponerlo en el lugar que deseemos. si bien podemos ajustarlas con posterioridad.

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

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

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. 25 . siendo el más habitual el uso de la tecla Tab para ir avanzando según un orden preestablecido. estado en el cual las pulsaciones de teclado van dirigida a ese control y no a los demás que hubiese en la ventana. También puede otorgarse de forma directa a un cierto control haciendo clic sobre él con el puntero del ratón. El foco de entrada puede desplazarse de un control a otro.

Para poderla utilizar sólo hay que definirla indicando cual será su nombre y cuál será el tipo de datos que podrá almacenar. El primer carácter debe de empezar con letra o con el carácter subrayado _. 2. un método. 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. 4. un nombre con el que identificaremos algún elemento de nuestro código. No debe de llevar espacios. como su propio nombre indica. etc. No debe de llevar caracteres especiales.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. Es sensible a mayúsculas. 5. 3. Las reglas son las siguientes: 1. ya sea una clase. 26 . una variable. lo que se hace siguiendo la sintaxis: Tipo_ de_ Dato nombre_de_variable. en C# un identificador no es más que. No usar palabras reservadas. Al igual que en cualquier lenguaje de programación.

147. // Guardar números con punto decimal carac='6'. num=53.0×10-324 . char carac.648 . int num.483.4×1038] true. Tipos de Datos Los tipos de datos se puede decir que son como contenedores donde tú colocas valores. no lo puedes guardar en un contenedor de números. // 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.147. ‘\uFFFF’] [5. Guardar datos en una variable: cad="aquí se guarda una cadena". si podrás guardarlo en un contendor de número pero antes tienes que hacer una conversión.7×10308] Ejemplos de declaración de variables: string cad. //Guardar números Enteros flotante =14. false [‘\u0000’.483.1. bool log.3. tiene que ser en uno de caracteres. Pero si quieres guardar caracteres que son números (“45”).Tecnologías de la Información y Comunicación 23+321 //no valida contiene un carácter especial (+). float flotante. si tú deseas guardar caracteres (“ABC!”#”).647] [1. 2. // Guardar un Carácter log=true.34.5×10-45 . esto lo veremos más adelante.

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

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

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

resultados de operaciones aritméticas como sumas o multiplicaciones. 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.1 + 3 asociación por la izquierda: 4 31 . de tipos enteros o reales.Tecnologías de la Información y Comunicación Existe un conjunto de operadores para cada tipo de datos. por ejemplo.-(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 . Tenemos. contenidos de variables numéricas.Signo negativo ++ Incremento -. operadores aritméticos para construir expresiones numéricas.Decremento Precedencia: ++ -. 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. Pueden ser constantes.

== != < <= > >= 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). devolviendo como resultado un valor booleano (entero). pero asociativa a izq.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. Operadores binarios: && AND (hace la conjunción lógica de dos valores bool). 32 . para operadores con igual precedencia. 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. (Retorna: 2) 3 * (4 % 5) los paréntesis alteran la precedencia (Retorna: 12) 1 + 15 % 6 % tiene precedencia mayor (Retorna: 4) Expresiones Relacionales. En C# se conoce el tipo booleano como bool. 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. La asociación se aplica de izquierda a derecha.

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

} Salida: 10 es Mayor a 5 Ejemplo con operadores: string usu=”usuario”.equal(clave)) { Console. if(usu.WriteLine(a+" es Menor a "+b).WriteLine(a+" es Mayor a "+b). } Ejemplo: int a=10. } else { Console.equal(usu) && clave. } else { Console. Sintaxis: if(<condición>) { <Sentencias1>. if(a>b) { Console. } else { <Sentencias2>. si no ejecuta las sentecias2.WriteLine(" La clave es incorrecta "). } Salida: 10 es Mayor a 5 34 . b=5.WriteLine(" la clave es correcta "). clave=”clave”. Si es verdadero ejecuta las sentencias1.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).

a = 3. Su sintaxis de uso es: 35 . } Salida: Opción 3 Sentencia While La instrucción while permite ejecutar un bloque de sentencias mientras sea verdadera la condición. Sintaxis: switch ( <expresión> ) { case <valor 1>: <Sentencias>. break. break.WriteLine("No seleccionaste ninguna"). break. break. . default: <Sentencias>.WriteLine("Opción 1"). break.WriteLine("Opción 3"). switch (a) { case 1: Console. break. } // El break se utiliza para terminar con el switch Ejemplo: int a.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. case 3: Console. case <valor 2>: <Sentencias>. . case 2: Console. . break.WriteLine("Opción 2"). default: Console. break. case <valor n>: <Sentencias>.

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

<modificación>) { <sentencias>. 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. i++. Luego se evalúa <condición>. } Salida: 0 1 2 3 4 5 6 7 8 9 37 . Ejemplo: int c.Write(c + " "). } El significado de esta instrucción es el siguiente: se ejecutan las sentencias de <inicialización>. <condición>. y si es falsa se continúa ejecutando por la instrucción siguiente al for.y luego se reevalúa <condición> repitiéndose el proceso hasta que ésta última deje de ser cierta. Sintaxis: for (<inicialización>.Tecnologías de la Información y Comunicación int i = 0. 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>. que suelen usarse para definir e inicializar variables que luego se usarán en <sentencias>. mientras que si es cierta se ejecutan las <sentencias> indicadas. do { Console. for (c = 0. c < 10. Se utiliza cuando se conoce el número de interacciones o cuando se requiere un contador.Write(i + " "). } while (i < 5). c++) { Console.

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. de cuáles son los datos y los métodos de los que van a disponer todos los objetos de ese tipo. class <nombreClase> { <atributos o campos> <métodos> } Campos Un campo es un dato común a todos los objetos de una determinada clase. los tipos de datos se organizan en espacio de nombres. Por otro lado. 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. los espacios de nombres también permiten poder usar en un mismo programa varias clases con igual nombre si pertenecen a espacios diferentes. 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 . Por esta razón. Es decir. namespace <nombreEspacio> { <tipos o clases> } CLASES Una clase es la definición de las características concretas de un determinado tipo de objetos. se suele decir que el tipo de dato de un objeto es la clase que define las características del mismo.

// métodos } Para acceder a un campo de un determinado objeto se usa la sintaxis: <objeto>. 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. por lo que como al principio del 39 . El <encapsulamiento> es el tipo de ocultamiento de los datos los principales son: public. 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. Los campos de un objeto son a su vez objetos. 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.nombre=”Un Nombre”.<campo> Ejemplo para un objeto llamado obj: obj. protected char caracter. y en <tipoDato> hemos de indicar cuál es el tipo de dato del objeto que vamos a crear. prívate y protected. Ejemplo: class datospersonales { // atributos o campos public string nombre.Tecnologías de la Información y Comunicación <encapsulamiento> <tipoDato> <nombreCampo>.

Todo método puede devolver un objeto como resultado de la ejecución de las sentencias que lo forman. los métodos permiten manipular los datos almacenados en los objetos. prívate y protected. // metodos public void Cumpleaños() { Edad++. siempre han de ser de los mismos tipos y han de seguir el orden establecido en <parametros>. Si no devuelve nada se indica void. Aunque los objetos que puede recibir el método pueden ser diferentes cada vez que se solicite su ejecución. private int edad. Ejemplos: <encapsulamiento> public <tipoDatoDevuelto> void <nombreMétodo> (<parametros>) mostraramigos (string nombreamigo) class datospersonales { //atributos o campos public string nombre. y el tipo de dato al que pertenece este objeto es lo que se indica en <tipoDatoDevuelto>. // Incrementa en uno de la edad del clase 40 . 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ó. protected char caracter. 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. 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.

// método que no regresa nada // este método regresa una cadena que se puede guardar en cualquier variable de tipo cadena string str. str = p. se escribe: <nombreobjeto>. } // método con parámetros de entrada public void mostraramigos(string nombreamigo.Cumpleaños(). int edadamigo) { Console.mostraramigo(“Joel”.<nombremétodo>(<parámetros>). Por ejemplo. Salida: Joel de 20 años es amigo de Luis 41 . // 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. 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). O sea. Como es lógico.Tecnologías de la Información y Comunicación } public string regresarnombre() // MEtodo que regresa un dato { return nombre. 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. } } La sintaxis usada para llamar a los métodos de un objeto es la misma que la usada para llamar a sus campos.regresanombre().20).

devolviendo una referencia al objeto recién creado. por tal motivo no se coloca ningún TipoDatoDevuelto como en los métodos. 42 . sino una referencia a la dirección de memoria dinámica donde en realidad se ha creado. esto depende de las necesidades que tenga nuestra aplicación. pero si puede tener parámetros de entrada.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>). 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(). // Crear un objeto de la clase datos Una clase puede contener n constructores. 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. 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. 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 tu agregas un constructor con parámetros ya no podrás usar el constructor vacio al menos que lo agregues. Las clases toman como default un constructor vacio. no tiene sentido que un constructor devuelva objetos. Un constructor no regresa ningún dato.

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

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. 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. es decir aunque tenga código si esta dentro de estos símbolos serán comentarios. } public string regresarnombre() // MEtodo que regresa un dato { return nombre. 44 . 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..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.Creamos un proyecto de tipo Consola.

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

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

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

temp8 .temp19. todas las variables contenidas en el arreglo son referidos como elementos los cuales deben ser del mismo tipo.temp12. la primera localidad es 0 y la ultima es el tamaño menos 1. incluyen declarar toda la lista.temp14.temp3.temp5. supongamos que somos un meteorólogo y queremos guardar en el ordenador la temperatura que ha hecho cada hora del día. int temp17. Para darle cierta utilidad al final calcularemos la media de las temperaturas.temp21.temp15. Con lo que sabemos hasta ahora sería algo así (que nadie se moleste ni en probarlo): class { int temp1. por lo que el tipo del arreglo.temp9.temp20. realizar operaciones con ellos.temp18.temp6. temp16.temp11.temp23. int temp10.temp7. 50 . capturar sus elementos.temp22. desplegarlos.temp13. También reciben el nombre de vectores en álgebra o arreglos unidimensionales en programación. 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.temp4. Pero ¿qué quiere decir esto y para qué lo queremos? Pues bien. Los procesos normales con una lista o con sus elementos.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. Los vectores empiezan desde la localidad 0. desplegarlos. etc. 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.temp2.

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

52 . Para declarar un objeto de declara de la siguiente manera miclase[] vectorarreglo = new miclase[20].metodos y eventos son de un arreglo. Foreach La Sentencia foreach es un comando que lee cada elemento de un colección (arreglo). La variable de iteración representa el elemento de la colección para cada iteración.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. vectorarreglo[indice]. Identificador: es un nombre para el objeto creado. Colección: es el arreglo del cual se va a leer cada elemento. string.mimetodo(). Cuando utilizas solamente el nombre del vector los atributos. 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(Tipo indentificador in colección){ } La variable de iteración es declarada por el Tipo. etc. Una vez que se declara el vector de objetos necesitas inicializar cada objeto del arreglo. un arreglo de objetos es creado utilizando new. Ejemplo: vectorarreglo[indice] = new miclase(). indentificador y expresión correspondiente a la colección. Tipo: puede ser un int.

para poder obtener la longitud de un array se usa la propiedad Length. } } public void imprimir() {// hacemos un recorrido al arreglo para mostrar los datos for (int i = 0. public void leerdatos() { // guardamos un elemento en cada localidad de arreglo for (int i = 0.ReadLine(). Ejemplo: miarreglo. 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.Length Existe un metodo llamdo Resize que se utiliza para cambiar el tamaño del arreglo en caso de que sea necesario.Write("Dame un Valor:"). tamaño). Pero cuando utilizas ref entra la entidad y si es modificada se regresa modificada. a[i]=Console.Resize(ref miarreglo. Por ejemplo. Se puede utilizar las propiedades y otros miembros que tiene esta clase para manupular los arrays. i++) 53 . 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]. Array. i++) { Console. i < 10.Tecnologías de la Información y Comunicación Clase Array La clase Array proporciona muchos métodos y propiedades para manipular arrays. i < 10.

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

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

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

ejemplo si tu pides un numero y el usuario introduce letras a la hora que quieres utilizar ese numero.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. 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ó. try { //Sentencias } catch (Exception ex) { // Sentencias } finally { // Sentencias } 57 . el finally es opcional. si no que suceden cuando tu ejecutas el programa. Para mostrar los datos del error cometido utilizamos la propiedad Message del objeto Exception. 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. Para asegurar de que un bloque de se ejecute se utiliza el finally. Es independientemente de que se lance una excepción o no. no lo puedes hacer porque si tratas de convertirlo a numero va a marcar un error de formato. 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.

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

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

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

Sign up to vote on this title
UsefulNot useful