P. 1
Manual de POO

Manual de POO

|Views: 44|Likes:

More info:

Published by: Juan Jesus Ramirez Gonzalez on Apr 24, 2012
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

01/27/2013

pdf

text

original

Sections

  • UNIDAD I
  • PROGRAMACIÓN ORIENTADA A OBJETOS
  • OBJETOS
  • ¿Qué es un Objeto?
  • ¿Qué se puede considerar como objeto?
  • CLASES
  • Clasificación:
  • OBJETOS Y CLASES
  • Dentro de una clase
  • ABSTRACCIÓN Y ENCAPSULAMIENTO
  • HERENCIA
  • POLIMORFISMO
  • UNIDAD II
  • ORIGEN Y NECESIDAD DE UN NUEVO LENGUAJE
  • CARACTERÍSTICAS DE C#
  • CARACTERÍSTICAS GENERALES DEL LENGUAJE
  • INICIAR C#
  • CREAR UN PROYECTO
  • ELEMENTOS DE TRABAJO
  • Cómo crear aplicaciones de consola
  • Cómo crear aplicaciones con ventanas
  • Controles más usuales y sus características
  • Propiedades, métodos y eventos comunes
  • UNIDAD III
  • IDENTIFICADORES Y TIPOS DE DATO
  • Variables o identificadores
  • Tipos de Datos
  • CLASE CONSOLE
  • Método para Mostrar Dato en Pantalla
  • Mostrar un mensaje y el valor de las variables
  • Leer datos del Teclado
  • CLASE CONVERT
  • EXPRESIONES
  • Expresiones Aritméticas
  • Expresiones Relacionales, Lógicas o Booleanas
  • SENTENCIAS DE CONTROL
  • Sentencia if
  • Opción Múltiple o Expresiones Multivaluadas: switch
  • Sentencia While
  • Sentencia Instrucción do...while
  • Sentencia for
  • CREACIÓN DE CLASES
  • Namespace
  • Campos
  • Métodos
  • OBJETO
  • COMENTARIOS
  • EJERCICIOS
  • UNIDAD IV
  • ARREGLO TIPO LISTA (UNIDIMESIONALES)
  • Declaración de Vectores
  • Crear Arreglo de Objetos
  • Foreach
  • Clase Array
  • EXCEPCIONES

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

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

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

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. 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.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. tanto externos como de otros objetos específicos que se encuentran dentro del sistema. 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 desarrollo es referido a la primera parte del ciclo de vida del software: análisis.

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

4 . Clase: Tipo de datos definido por el usuario Objeto: Es un dato del tipo definido por su clase. es decir.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. Sin embargo. Primera: nombre de la 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. es una instancia específica de su clase Una clase se representa por una caja la cual puede tener 3 regiones.

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

y "comunicarse" con otros objetos en el sistema sin revelar cómo se implementan estas características. Protegido (Protect): heredadas. informar y cambiar su estado. Esto permite aumentar la cohesión de los componentes del sistema. En un sentido más específico. donde se capturan sus comportamientos. Los procesos. la abstracción localiza y oculta los detalles de un modelo o diseño para generar y manipular objetos. Encapsulamiento: Significa reunir a todos los elementos que pueden considerarse pertenecientes a una misma entidad. una abstracción es una representación concisa de una idea o de un objeto complicado. Algunos autores confunden este concepto con el principio de ocultación. Una clase puede definirse ampliamente y redefinirse sucesivamente en subclases más refinadas. al mismo nivel de abstracción. 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. Cerrado (Private). principalmente porque se suelen emplear conjuntamente.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. Tipos de encapsulamiento: • • • Abierto (Public): Puede accederse de cualquier parte del programa. 6 . las funciones o los métodos pueden también ser abstraídos En el sentido más general. Solo es desde las 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. hereda todas las propiedades de su superclase y adiciona sus propias y únicas propiedades. sino que se relacionan entre sí. Esto suele hacerse habitualmente agrupando los objetos en clases y estas en árboles o enrejados que reflejan un comportamiento común. 7 . Para ello es necesario que exista una clase base y una jerarquía de clases. formando una jerarquía de clasificación. Las clases que heredan propiedades de otra clase pueden servir como clase base de otras. añadiendo código o modificando lo heredado. Tipos herencias • • Simple Múltiple Ventajas Ayuda a los programadores a ahorrar código y tiempo. Estos pueden compartir (y extender) su comportamiento sin tener que volver a implementarlo. al ser posible reutilizar el mismo a lo largo de diferentes clases/objetos con comportamientos similares para un determinado aspecto.Tecnologías de la Información y Comunicación Cada subclase que se incorpora. La herencia permite reutilizar código Las clases no están aisladas. La clase derivada puede heredar código y datos de la clase base. Los objetos heredan las propiedades y el comportamiento de todas las clases a las que pertenecen.

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

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

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

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

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

Esto tiene el efecto en el lenguaje de que no es necesario incluir instrucciones de destrucción de objetos. 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. Sin embargo. por lo que en realidad el CLR y el compilador colaboran para asegurar la corrección de las conversiones. todo lenguaje de . 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ó. y entre un tipo y un tipo hijo suyo del que un objeto del primero almacenase una referencia del segundo (downcasting) Obviamente. entre tipos para los que explícitamente se haya definido un operador de conversión. 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. No se pueden usar variables no inicializadas. entre un tipo y antecesores suyos. C# también proporciona un mecanismo de liberación de recursos determinista a través de la instrucción using. Para ello se toman medidas del tipo: Sólo se admiten conversiones entre tipos compatibles. Seguridad de tipos: C# incluye mecanismos que permiten asegurar que los accesos a tipos de datos siempre se realicen correctamente.NET tiene a su disposición el recolector de basura del CLR. • Instrucciones seguras: Para evitar errores muy comunes. finalización de la aplicación o solicitud explícita en el fuente-. 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. 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. Esto es.

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

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

INICIAR C# Al iniciar Visual Studio por primera vez nos encontramos con un entorno como el que aparece en la figura 1. La Página de inicio aparece en primer plano.1 (página siguiente). 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. 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. 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. una barra de botones debajo y una serie de ventanas adosadas.net framework. d) BIBLIOTECA DE CLASES La biblioteca de clases de Microsoft.exe que viene incluido en microsof. Esta página estará vacía si no disponemos de una conexión a la red. 16 .net: este compilador produce archivos con extencio.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.exe. 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.

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

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

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

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. cuyo nombre es el introducido en la ventana Nuevo proyecto. A continuación se encuentra la definición de un espacio de nombres propio. using System. using System. añadiendo un módulo con el código siguiente: using System.Collections. Un clic en el botón Aceptar y el asistente creará el proyecto. en cuyo interior hay una 20 .Tecnologías de la Información y Comunicación por defecto.Generic.

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

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

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

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

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

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

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

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

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

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

Signo negativo ++ Incremento -. operadores aritméticos para construir expresiones numéricas. de manera que siempre es posible construir una nueva expresión a partir de una o varias ya existentes. Expresiones Aritméticas Las expresiones aritméticas son valores numéricos.-(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 . Operadores binarios: + * / % Suma Resta Multiplicación División Módulo (sólo sobre tipos de números enteros) Operadores unitarios: .Tecnologías de la Información y Comunicación Existe un conjunto de operadores para cada tipo de datos. de tipos enteros o reales. resultados de operaciones aritméticas como sumas o multiplicaciones.Decremento Precedencia: ++ -. o combinaciones de las anteriores unidas mediante operadores aritméticos. por ejemplo. y operadores lógicos para construir expresiones booleanas.1 + 3 asociación por la izquierda: 4 31 . contenidos de variables numéricas. Pueden ser constantes. Tenemos.

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

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

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

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

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

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

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

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

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

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

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

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

/* 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. 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. 44 . } public string regresarnombre() // MEtodo que regresa un dato { return nombre. Damos clic en el menú Archivo-NuevoProyecto. public void Cumpleaños() // Incrementa en uno de la edad del clase { Edad++.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. es decir aunque tenga código si esta dentro de estos símbolos serán comentarios. 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. 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. } */ Vamos a crear un ejemplo aplicando todo lo que se vio en este documento: 1..

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

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

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

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

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

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

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

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

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

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

no lo puedes hacer porque si tratas de convertirlo a numero va a marcar un error de formato. Es independientemente de que se lance una excepción o no. try { //Sentencias } catch (Exception ex) { // Sentencias } finally { // Sentencias } 57 . 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. si no que suceden cuando tu ejecutas el programa. el finally es opcional. El catch puede o no llevar un parámetro el cual contiene los datos del error que se cometió. Sintaxis: try { //Sentencias } catch { // Sentencias } Sintaxis para capturar los datos del error. Para mostrar los datos del error cometido utilizamos la propiedad Message del objeto Exception.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. ejemplo si tu pides un numero y el usuario introduce letras a la hora que quieres utilizar ese numero. Las excepciones son mas los errores que posiblemente puedan suceder que cuando introduce el código no suceden. Para asegurar de que un bloque de se ejecute se utiliza el finally. 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.

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

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

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

You're Reading a Free Preview

Descarga
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->