MANUAL DE APRENDIZAJE - virtual.senati.edu.pevirtual.senati.edu.pe/curri/file_curri.php/curri/PDSD/89001562... · elaborar casos prÁcticos utilizando estructuras repetitivas.....169

SERVICIO NACIONAL DE ADIESTRAMIENTO EN TRABAJO INDUSTRIAL

MANUAL DE APRENDIZAJE

CÓDIGO: 89001562

Profesional Técnico

LENGUAJE DE PROGRAMACIÓN I

COMPUTACIÓN E INFORMÁTICA


TABLA DE CONTENIDO I. ANALIZAR EL ENTORNO DE TRABAJO CON MICROSOFT VISUAL STUDIO. ............ 7

1.1. DEFINIR EL CONCEPTO DE VISUAL NET. ....................................................................... 8 1.2. ANALIZAR LA ESTRUCTURA DEL FRAMEWORK. .......................................................... 8 1.3. INSTALAR Y TRABAJAR CON EL ENTORNO DE DESARROLLO DE VISUAL NET. 9

FUNDAMENTO TEÓRICO. .................................................................................................... 14 DEFINIR EL CONCEPTO DE VISUAL NET. ............................................................................. 14 ANALIZAR LA ESTRUCTURA DEL FRAMEWORK. ............................................................... 15 INSTALAR Y TRABAJAR CON EL ENTORNO DE DESARROLLO DE VISUAL NET. ...... 23

II. DIFERENCIAR LA PROGRAMACIÓN POR CONSOLA Y CON FORMULARIOS. ........ 28

2.1. DEFINICIÓN DE UN PROYECTO EN VISUAL NET. ....................................................... 29 2.2. ELABORAR PROGRAMA EN MODO CONSOLA. ........................................................... 31 2.3. DISEÑAR Y PROGRAMAR UN FORMULARIO. ............................................................... 47

FUNDAMENTO TEÓRICO: .................................................................................................... 57 Definición de un proyecto en Visual Net. .................................................................................... 57 Elaborar programa en modo consola. ......................................................................................... 63 Diseñar y programar un formulario. ............................................................................................. 72

III. PROGRAMAR ESTRUCTURAS CONDICIONALES. ....................................................... 85

3.1. TRABAJAR CON CONSTANTES Y VARIABLES. ............................................................ 86 3.2. IDENTIFICAR LOS TIPOS DE DATOS QUE EXISTEN EN VISUAL NET. ................... 87 3.3. ANALIZAR LA IMPORTANCIA DE UNA ESTRUCTURA CONDICIONAL. ................... 88

FUNDAMENTO TEÓRICO. .................................................................................................. 100 Trabajar con constantes y variables. ........................................................................................ 100 IDENTIFICAR LOS TIPOS DE DATOS QUE EXISTEN EN VISUAL NET: ........................ 108 ANALIZAR LA IMPORTANCIA DE UNA ESTRUCTURA CONDICIONAL. ........................ 117

IV. PROGRAMAR ESTRUCTURAS REPETITIVAS. ............................................................ 140

4.1. DEFINIR UNA ESTRUCTURA REPETITIVA: .................................................................. 141 4.2. TIPOS DE ESTRUCTURAS REPETITIVAS EN VISUAL NET. ..................................... 141 4.3. ELABORAR CASOS PRÁCTICOS UTILIZANDO ESTRUCTURAS REPETITIVAS. 142

FUNDAMENTO TEÓRICO. .................................................................................................. 158 TIPOS DE ESTRUCTURAS REPETITIVAS EN VISUAL NET. ............................................ 158 DEFINIR UNA ESTRUCTURA REPETITIVA. ......................................................................... 158 ELABORAR CASOS PRÁCTICOS UTILIZANDO ESTRUCTURAS REPETITIVAS. ........ 169

V. PROGRAMAR ESTRUCTURAS ANIDADAS SIMPLES Y COMPLEJAS. .................... 190

5.1. DEFINIR LA IMPORTANCIA DE ANIDAR CORRECTAMENTE DOS O MÁS ESTRUCTURAS. ......................................................................................................................... 191 5.2. DESARROLLAR ESTRUCTURAS ANIDADAS PARA LA SOLUCIÓN DE PROBLEMAS. .............................................................................................................................. 192

FUNDAMENTO TEÓRICO: .................................................................................................. 195 Definir la importancia de anidar correctamente dos o más estructuras.............................. 195 DESARROLLAR ESTRUCTURAS ANIDADAS PARA LA SOLUCIÓN DE PROBLEMAS. 197

VI. ELABORAR PROCEDIMIENTOS PARA RESOLVER CASOS PRÁCTICOS. .............. 200

6.1. IDENTIFICAR LA IMPORTANCIA DE UN PROCEDIMIENTO. .................................... 201 6.2. PROGRAMAR PROCEDIMIENTOS PARA RESOLVER CASOS PRÁCTICOS. ....... 202

FUNDAMENTO TEÓRICO. .................................................................................................. 220 Identificar la importancia de un procedimiento. ....................................................................... 220 PROGRAMAR PROCEDIMIENTOS PARA RESOLVER CASOS PRÁCTICOS. .............. 223

ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN 5




I. ANALIZAR EL ENTORNO DE TRABAJO CON MICROSOFT VISUAL STUDIO.

En esta tarea trataremos las siguientes operaciones:

Definir el concepto de Visual Net. Analizar la estructura del Framework. Instalar y trabajar con el entorno de desarrollo de Visual Net.

Equipos y Materiales:

Computadora con microprocesadores core 2 Duo o de mayor capacidad.

Sistema operativo Windows. Acceso a internet. Software de maquetación y desarrollo de páginas web.

Orden de Ejecución:

Definir el concepto de Visual Net. Analizar la estructura del Framework. Instalar y trabajar con el entorno de desarrollo de Visual Net.

01



1.1. DEFINIR EL CONCEPTO DE VISUAL NET.

Visual Basic es hoy el lenguaje de programación más popular del mundo.

.Net conduce a la tercera generación de Internet. La primera generación consistió en trabajar con información estática que podía ser consultada a través de exploradores como si de un tablón de noticias se tratara. La segunda generación se ha basado en que las aplicaciones pudieran interaccionar con las personas; sirva como ejemplo los famosos carros de compra. La tercera generación se caracterizara por aplicaciones que puedan interaccionar con otras aplicaciones; por ejemplo una reunión de negocios, su aplicación de contactos interaccionara con su aplicación de calendario que, a su vez, interaccionara con una aplicación de reserva de billetes para viajar en avión, que consultara a su aplicación preferencias de usuario por si tuviera que cancelar alguna actividad ya programada.

Precisamente, el principio de .Net es que los sitios Web aislados y los diferentes dispositivos trabajen conectados a través de Internet para ofrecer soluciones mucho más ricas. Esto se conseguirá gracias a la aceptación de los estándares abiertos basados en XML. (Extensible Markup Languaje – Lenguaje extensible para describir documentos). De esta manera, Internet se convierte en una fuente de servicios, no sólo de datos.

En definitiva, Internet y XML han dado lugar a una nueva fase de la informática en la que los datos del usuario residen en Internet, no en un ordenador personal, y se puede acceder a ellos desde cualquier ordenador de sobremesa, portátil, teléfono móvil o agenda de bolsillo (PDA: Personal Digital Assistant). Ello se debe fundamentalmente a que XML ha hecho posible que se puedan crear aplicaciones potentes, para ser utilizadas por cualquiera, desde cualquier lugar.

1.2. ANALIZAR LA ESTRUCTURA DEL FRAMEWORK.

.NET Framework es una plataforma de desarrollo para compilar aplicaciones para Windows, Windows Phone, Windows Server y Windows Azure. Está formado por Common Language Runtime (CLR) y la biblioteca de clases de .NET Framework, que incluye clases, interfaces y tipos de valor que son compatibles con una amplia gama de tecnologías. .NET Framework proporciona un entorno de ejecución administrado, un desarrollo e implementación simplificados y la integración con una gran variedad de lenguajes de programación, incluidos Visual Basic y Visual C#.

Se requiere una estructura, no solo para facilitar el desarrollo de aplicaciones, sino también para hacer que el proceso de encontrar un servicio Web e



integrarlo en una aplicación resulte transparente para usuarios y desarrolladores: .NET Framework proporciona esa estructura.

Según se puede ver en la figura siguiente, .NET Framework es un componente de desarrollo multilenguaje y un entorno de ejecución:

1.3. INSTALAR Y TRABAJAR CON EL ENTORNO DE DESARROLLO DE VISUAL NET.

La instalación de esta versión es un proceso realmente sencillo. Lejos queda la instalación de la versión 2.003 que era realmente engorrosa, así que vamos a seguir estos sencillo pasos para instalar nuestro Visual Basic.

Todo lo referente a las versiones Express de Microsoft se encuentran en la página Web: http://www.microsoft.com/express así que nos iremos a esta página:


http://www.microsoft.com/express


Este es el centro de todo el mundo "Express" de Microsoft, vamos a hacer clic en el menú "Download" que aparece en la barra y que te he marcado con un recuadro rojo para acceder a los programas que conforman el Visual Studio 2.010:

Tenemos dos formas de instalar el programa: conectado a Internet con instalación en línea o descargando el DVD y luego realizando la instalación en local.



Por experiencia he visto que la instalación Web no os ha funcionado en todos los casos así que este año vamos a cambiar y nos vamos a descargar el DVD completo, así haremos todo de una vez. Seleccionaremos la parte inferior en la que pone "All - Offline Install ISO image file" y luego la versión en español:

Se abrirá la habitual ventana de descarga de ficheros:

Así que lo descargaremos completo, ya vez que tiene 1,71 GB así que un poco de paciencia pero mejor tenerlo en nuestro equipo descargado. Una vez descargado tenemos un fichero con extensión .ISO que es un fichero de imagen para grabarlo en un DVD. Podemos evitarnos esto de una forma muy sencilla, nos descargaremos uno de los descompresores más conocidos y que se llama WinRAR. Lo descargaremos desde la página www.WinRAR.es y lo instalamos.


http://www.winrar.es/


También nos valdría un programa para montar imágenes "ISO" como unidades pero así lo podemos hacer de una forma rápida y sencilla. Al ejecutarlo como ves en la pantalla anterior le asocia los ficheros con extensión "ISO" que es lo que queremos. Así que una vez descargada la imagen de .NET e instalado este descompresor, asociando las extensiones ISO, podemos irnos al administrador de archivos para indicar que nos descomprima el DVD que nos hemos descargado en una carpeta. Para eso solo pincharemos con el botón derecho del ratón para indicar en el menú contextual:

Ya lo tenemos descomprimido así que nos vamos a la carpeta y hacemos doble clic sobre el fichero "Setup.Hta" que nos mostrará esta pantalla:



Así que finalmente pulsaremos en "Visual Basic 2010 Express".

Al cabo de unos momentos tendremos el asistente de instalación en pantalla:

Pulsamos en "Siguiente" para comenzar la instalación...



Y al cabo de unos minutos nos mostrará que el proceso ha finalizado...

Puede que nos pida reinicio, lo hacemos y ya tenemos nuestro Visual Basic 2010 instalado. Hasta aquí ha sido todo muy fácil.

FUNDAMENTO TEÓRICO.

DEFINIR EL CONCEPTO DE VISUAL NET.

Visual Basic .NET (VB.NET) es un lenguaje de programación orientado a objetos que se puede considerar una evolución de Visual Basic implementada sobre el framework .NET. Su introducción resultó muy controvertida, ya que debido a cambios significativos en el lenguaje VB.NET no es retrocompatible con Visual Basic, pero el manejo de las instrucciones es similar a versiones anteriores de Visual Basic, facilitando así el desarrollo de aplicaciones más avanzadas con herramientas modernas.

La gran mayoría de programadores de VB.NET utilizan el entorno de desarrollo integrado Microsoft Visual Studio en alguna de sus versiones (desde el primer Visual Studio .NET hasta Visual Studio .NET 2012, que es la última versión de Visual Studio para la plataforma .NET), aunque existen otras alternativas, como SharpDevelop (que además es libre).

Al igual que con todos los lenguajes de programación basados en .NET, los programas escritos en VB .NET requieren el Framework .NET o Mono para ejecutarse.

Visual Basic 2010 ofrece soporte para entorno de ejecución dinámico..

VB 2010 forma parte de Microsoft Silverlight. visual basic es un lenguaje de programacion que permite realizar diferentes programas de registro anudados.



ANALIZAR LA ESTRUCTURA DEL FRAMEWORK.

La palabra inglesa "framework" (marco de trabajo) define, en términos generales, un conjunto estandarizado de conceptos, prácticas y criterios para enfocar un tipo de problemática particular que sirve como referencia, para enfrentar y resolver nuevos problemas de índole similar.

En el desarrollo de software, un framework o infraestructura digital, es una estructura conceptual y tecnológica de soporte definido, normalmente con artefactos o módulos de software concretos, que puede servir de base para la organización y desarrollo de software. Típicamente, puede incluir soporte de programas, bibliotecas, y un lenguaje interpretado, entre otras herramientas, para así ayudar a desarrollar y unir los diferentes componentes de un proyecto.

Representa una arquitectura de software que modela las relaciones generales de las entidades del dominio, y provee una estructura y una especial metodología de trabajo, la cual extiende o utiliza las aplicaciones del dominio.

Son diseñados con la intención de facilitar el desarrollo de software, permitiendo a los diseñadores y programadores pasar más tiempo identificando requerimientos de software que tratando con los tediosos detalles de bajo nivel de proveer un sistema funcional. Por ejemplo, un equipo que usa Apache Struts para desarrollar un sitio web de un banco, puede enfocarse en cómo los retiros de ahorros van a funcionar en lugar de preocuparse de cómo se controla la navegación entre las páginas en una forma libre de errores. Sin embargo, hay quejas comunes acerca de que el uso de frameworks añade código innecesario y que la preponderancia de frameworks competitivos y complementarios significa que el tiempo que se pasaba programando y diseñando ahora se gasta en aprender a usar los frameworks.

Fuera de las aplicaciones en la informática, puede ser considerado como el conjunto de procesos y tecnologías usados para resolver un problema complejo. Es el esqueleto sobre el cual varios objetos son integrados para facilitar una solución dada.

.Net Framework

.NET Framework es un entorno de ejecución administrado que proporciona diversos servicios a las aplicaciones en ejecución. Consta de dos componentes principales: Common Language Runtime (CLR), que es el motor de ejecución que controla las aplicaciones en ejecución; y la biblioteca de clases de .NET Framework, que proporciona una biblioteca de código probado y reutilizable al que pueden llamar los desarrolladores desde sus propias aplicaciones. Los servicios que ofrece .NET Framework a las aplicaciones en ejecución son los siguientes:



• Administración de la memoria. En muchos lenguajes de programación, los programadores son responsables de asignar y liberar memoria y de administrar duraciones de objeto. En las aplicaciones de .NET Framework, CLR proporciona estos servicios en nombre de la aplicación.

• Sistema de tipos comunes. En los lenguajes de programación tradicionales, el compilador definen los tipos básicos, que complica la interoperabilidad entre lenguajes. En .NET Framework, los tipos básicos se definen según el sistema de tipos de .NET Framework y son comunes para todos los lenguajes cuyo destino es .NET Framework.

• Biblioteca de clases extensa. En lugar de tener que escribir cantidades extensas de código para controlar operaciones comunes de programación de bajo nivel, los programadores puede usar una biblioteca de tipos de acceso directo y sus miembros de la biblioteca de clases de .NET Framework.

• Frameworks y tecnologías de desarrollo. .NET Framework incluye bibliotecas para determinadas áreas de desarrollo de aplicaciones, como ASP.NET para aplicaciones web, ADO.NET para el acceso a los datos y Windows Communication Foundation para las aplicaciones orientadas a servicios.

• Interoperabilidad de lenguajes. Los compiladores de lenguajes destinados a .NET Framework emiten un código intermedio denominado Lenguaje intermedio común (CIL), que, a su vez, se compila en tiempo de ejecución por Common Language Runtime. Con esta característica, unos lenguajes pueden acceder a las rutinas escritas en otros, y los programadores pueden concentrarse en crear aplicaciones en su lenguaje o lenguajes preferidos.

• Compatibilidad de versiones. Con raras excepciones, las aplicaciones que se desarrollan con una versión determinada de .NET Framework se pueden ejecutar sin modificaciones en una versión posterior.

• Ejecución en paralelo. .NET Framework ayuda a resolver conflictos entre versiones permitiendo que varias versiones de Common Language Runtime existan en el mismo equipo. Esto significa que también pueden coexistir varias versiones de las aplicaciones, y que una aplicación se puede ejecutar en la versión de .NET Framework con la que se compiló.

• Compatibilidad con múltiples versiones (multi-targeting). Al usar la Biblioteca de clases portable de .NET Framework, los desarrolladores pueden crear ensamblados que funcionan en varias plataformas de .NET Framework, como Windows 7, Windows 8, Windows Phone y Xbox 360.



.NET Framework para usuarios.

Si no desarrollara aplicaciones de .NET Framework, pero las usa, no es necesario tener conocimiento concreto sobre .NET Framework o su funcionamiento.En general, .NET Framework es completamente transparente para los usuarios.

Si usa el sistema operativo Windows, es posible que .NET Framework ya esté instalado en el equipo. Además, si instala una aplicación que requiera .NET Framework, el programa de instalación de la aplicación puede instalar una versión concreta de .NET Framework en el equipo. En algunos casos, puede aparecer un cuadro de diálogo que le pide que instale .NET Framework. Si acaba de intentar ejecutar una aplicación cuando aparece este cuadro de diálogo y si el equipo tiene acceso a Internet, puede ir a una página web que le permita instalar la versión de .NET Framework que falta.

En general, no debe desinstalar ninguna versión de .NET Framework que esté instalada en el equipo, porque una aplicación que use puede depender de una versión concreta y se puede interrumpir si se quita esa versión. Observe que varias versiones de .NET Framework se pueden cargar en un único equipo al mismo tiempo. Esto significa que no tiene que desinstalar las versiones anteriores para instalar una versión posterior.

.NET Framework para Silverlight para desarrolladores.

Si es desarrollador, puede elegir cualquier lenguaje de programación compatible con .NET Framework para crear la aplicación. Dado que .NET Framework proporciona independencia e interoperabilidad entre lenguajes, puede interactuar con otras aplicaciones de .NET Framework y componentes independientemente del lenguaje con el que se desarrollaron.

Para desarrollar aplicaciones o componentes de .NET Framework, haga lo siguiente:

1. Instale la versión de .NET Framework que será destino de su aplicación. La versión de producción más reciente es .NET Framework 4.5. .NET Framework 4.5.1, que se libera con Visual Studio 2013 y se incluye con Windows 8.1 Preview, también está disponible desde el centro de descarga. Hay paquetes adicionales de .NET Framework que se liberan fuera de banda. Para obtener información acerca de estos paquetes, vea .NET Framework y versiones fuera de banda.

2. Seleccione el lenguaje o los lenguajes de .NET Framework que utilizará para desarrollar las aplicaciones. Varios idiomas están disponibles, incluido Visual



Basic, C#, Visual F# y C++ en Microsoft. (Un lenguaje de programación que permite desarrollar aplicaciones de .NET Framework se adhiere a la especificación de Common Language Infrastructure (CLI).) Para obtener una lista de lenguajes de programación disponibles, vea Lenguajes de Visual Studio.

3. Seleccione e instale el entorno de desarrollo que utilizará para crear aplicaciones y que admita el lenguaje o los lenguajes de programación que seleccione. El entorno de desarrollo integrado de Microsoft para las aplicaciones de .NET Framework es Descargas de Visual Studio. Está disponible en diversas ediciones de minoristas y gratuitas.

.NET Framework es una tecnología que admite la compilación y la ejecución de la siguiente generación de aplicaciones y servicios Web XML. El diseño de .NET Framework está enfocado a cumplir los objetivos siguientes:

• Proporcionar un entorno coherente de programación orientada a objetos, en el que el código de los objetos se pueda almacenar y ejecutar de forma local, ejecutar de forma local pero distribuida en Internet o ejecutar de forma remota.

• Proporcionar un entorno de ejecución de código que minimiza los conflictos en el despliegue y versionado de software.

• Ofrecer un entorno de ejecución de código que promueva la ejecución segura del mismo, incluso del creado por terceras personas desconocidas o que no son de plena confianza.

• Proporcionar un entorno de ejecución de código que elimine los problemas de rendimiento de los entornos en los que se utilizan scripts o intérpretes de comandos.

• Ofrecer al programador una experiencia coherente entre tipos de aplicaciones muy diferentes, como las basadas en Windows o en el Web.

• Basar toda la comunicación en estándares del sector para asegurar que el código de .NET Framework se puede integrar con otros tipos de código.

.NET Framework está compuesto por dos componentes principales: Common Language Runtime y la biblioteca de clases de .NET Framework. Common Language Runtime es el fundamento de .NET Framework. El motor en tiempo de ejecución se puede considerar como un agente que administra el código en tiempo de ejecución y proporciona servicios centrales, como la administración de memoria, la administración de subprocesos y la comunicación remota, al



tiempo que aplica una seguridad estricta a los tipos y otras formas de especificación del código que promueven su seguridad y solidez. De hecho, el concepto de administración de código es un principio fundamental del motor en tiempo de ejecución. El código destinado al motor en tiempo de ejecución se denomina código administrado, a diferencia del resto de código, que se conoce como código no administrado. La biblioteca de clases es una completa colección orientada a objetos de tipos reutilizables que se pueden emplear para desarrollar aplicaciones que abarcan desde las tradicionales herramientas de interfaz gráfica de usuario (GUI) o de línea de comandos hasta las aplicaciones basadas en las innovaciones más recientes proporcionadas por ASP.NET, como los formularios Web Forms y los servicios Web XML.

.NET Framework puede hospedarse en componentes no administrados que cargan Common Language Runtime en sus procesos e inician la ejecución de código administrado, con lo que se crea un entorno de software en el que se pueden utilizar características administradas y no administradas. En .NET Framework no sólo se ofrecen varios hosts de motor en tiempo de ejecución, sino que también se admite el desarrollo de estos hosts por parte de terceros.

Por ejemplo, ASP.NET hospeda el motor en tiempo de ejecución para proporcionar un entorno de servidor escalable para el código administrado. ASP.NET trabaja directamente con el motor en tiempo de ejecución para habilitar aplicaciones de ASP.NET y servicios Web XML, que se tratan más adelante en este tema.

Internet Explorer es un ejemplo de aplicación no administrada que hospeda el motor en tiempo de ejecución (en forma de una extensión de tipo MIME). Al usar Internet Explorer para hospedar el motor en tiempo de ejecución, puede incrustar componentes administrados o controles de Windows Forms en documentos HTML. Al hospedar el runtime de esta manera se hace posible el uso de código móvil administrado, pero con mejoras significativas que sólo el código administrado puede ofrecer, como la ejecución con confianza parcial y el almacenamiento aislado de archivos.

En la ilustración siguiente se muestra la relación de Common Language Runtime y la biblioteca de clases con las aplicaciones y el sistema en su conjunto. En la ilustración se representa igualmente cómo funciona el código administrado dentro de una arquitectura mayor.



.NET Framework en contexto.

En las secciones siguientes se describen con más detalle las características principales de .NET Framework.

Características de Common Language Runtime.

Common Language Runtime administra la memoria, ejecución de subprocesos, ejecución de código, comprobación de la seguridad del código, compilación y demás servicios del sistema. Estas características son intrínsecas del código administrado que se ejecuta en Common Language Runtime.

Con respecto a la seguridad, los componentes administrados reciben grados de confianza diferentes, en función de una serie de factores entre los que se incluye su origen (como Internet, red empresarial o equipo local). Esto significa que un componente administrado puede ser capaz o no de realizar operaciones de acceso a archivos, operaciones de acceso al Registro y otras funciones delicadas, incluso si se está utilizando en la misma aplicación activa.

El motor en tiempo de ejecución impone la seguridad de acceso del código. Por ejemplo, los usuarios pueden confiar en que un archivo ejecutable incrustado en una página Web puede reproducir una animación en la pantalla o entonar una canción, pero no puede tener acceso a sus datos personales, sistema de archivos o red. Por ello, las características de seguridad del motor en tiempo de ejecución permiten que el software legítimo implementado en Internet sea excepcionalmente variado.

Además, el motor en tiempo de ejecución impone la solidez del código mediante la implementación de una infraestructura estricta de comprobación de tipos y código denominado CTS (Common Type System, Sistema de tipos común). CTS garantiza que todo el código administrado es autodescriptivo. Los



diversos compiladores de lenguaje de Microsoft y de otros fabricantes generan código administrado que se atiene al CTS. Esto significa que el código administrado puede consumir otros tipos e instancias administrados, al tiempo que se exige fidelidad de tipos y seguridad de tipos estrictamente.

Además, el entorno administrado del motor en tiempo de ejecución elimina muchos problemas de software comunes. Por ejemplo, el motor en tiempo de ejecución controla automáticamente la disposición de los objetos, administra las referencias a éstos y los libera cuando ya no se utilizan. Esta administración automática de la memoria soluciona los dos errores más comunes de las aplicaciones: la pérdida de memoria y las referencias no válidas a la memoria.

Además, el motor en tiempo de ejecución aumenta la productividad del programador. Por ejemplo, los desarrolladores pueden crear aplicaciones en el lenguaje que prefieran y seguir sacando todo el provecho del motor en tiempo de ejecución, la biblioteca de clases y los componentes escritos en otros lenguajes por otros colegas. El proveedor de un compilador puede elegir destinarlo al motor en tiempo de ejecución. Los compiladores de lenguajes que se destinan a .NET Framework hacen que las características de .NET Framework estén disponibles para el código existente escrito en dicho lenguaje, lo que facilita enormemente el proceso de migración de las aplicaciones existentes.

Aunque el motor en tiempo de ejecución está diseñado para el software del futuro, también es compatible con el software actual y el software antiguo. La interoperabilidad entre el código administrado y no administrado permite que los desarrolladores continúen utilizando los componentes COM y las DLL que necesiten.

El motor en tiempo de ejecución está diseñado para mejorar el rendimiento. Aunque Common Language Runtime proporciona muchos servicios estándar de motor en tiempo de ejecución, el código administrado nunca se interpreta. Una característica denominada compilación JIT (Just-In-Time) permite ejecutar todo el código administrado en el lenguaje máquina nativo del sistema en el que se ejecuta. Mientras tanto, el administrador de memoria evita que la memoria se pueda fragmentar y aumenta la zona de referencia de la memoria para mejorar aún más el rendimiento.

Por último, el motor en tiempo de ejecución se puede hospedar en aplicaciones de servidor de gran rendimiento, como Microsoft SQL Server e Internet Information Services (IIS). Esta infraestructura permite utilizar código administrado para escribir lógica empresarial, al tiempo que se disfruta del superior rendimiento de los mejores servidores empresariales del sector que pueda hospedar el motor en tiempo de ejecución.



Biblioteca de clases de .NET Framework.

La biblioteca de clases de .NET Framework es una colección de tipos reutilizables que se integran estrechamente con Common Language Runtime. La biblioteca de clases está orientada a objetos, lo que proporciona tipos de los que su propio código administrado puede derivar funciones. Esto ocasiona que los tipos de .NET Framework sean sencillos de utilizar y reduce el tiempo asociado con el aprendizaje de las nuevas características de .NET Framework.Además, los componentes de terceros se pueden integrar sin dificultades con las clases de .NET Framework.

Por ejemplo, las clases de colección de .NET Framework implementan un conjunto de interfaces que puede usar para desarrollar sus propias clases de colección. Éstas se combinarán fácilmente con las clases de .NET Framework.

Como en cualquier biblioteca de clases orientada a objetos, los tipos de .NET Framework permiten realizar diversas tareas de programación comunes, como son la administración de cadenas, recolección de datos, conectividad de bases de datos y acceso a archivos. Además de estas tareas habituales, la biblioteca de clases incluye tipos adecuados para diversos escenarios de desarrollo especializados. Por ejemplo, puede utilizar .NET Framework para desarrollar los siguientes tipos de aplicaciones y servicios:

• Aplicaciones de consola Vea Compilar aplicaciones de consola en .NET Framework.

• Aplicaciones GUI de Windows (Windows Forms) Vea Windows Forms.

• Aplicaciones de Windows Presentation Foundation (WPF) Vea Introducción a WPF.

• Aplicaciones de ASP.NET Vea Desarrollar aplicaciones web mediante ASP.NET.

• Servicios de Windows Vea Introducción a las aplicaciones de servicios de Windows.

• Aplicaciones orientadas a servicios utilizando Windows Communication Foundation (WCF). Vea Desarrollar aplicaciones orientadas a servicios mediante WCF.

• Aplicaciones habilitadas para el flujo de trabajo utilizando Windows Workflow Foundation (WF). Vea Crear flujos de trabajo en .NET Framework.

Por ejemplo, las clases de Windows Forms son un conjunto completo de tipos reutilizables que simplifican enormemente el desarrollo de interfaces GUI para



Windows. Si escribe una aplicación Web Form de ASP.NET, puede utilizar las clases de formularios Web Forms.

INSTALAR Y TRABAJAR CON EL ENTORNO DE DESARROLLO DE VISUAL NET.

Entorno de desarrollo.

Existe un único entorno de desarrollo para Visual Basic, desarrollado por Microsoft: Microsoft Visual Basic x.0, correspondientes a versiones desde la 1.0 hasta la 6.0, (con respectivas diferencias entre versiones del lenguaje).

El entorno de desarrollo es muy similar al de otros lenguajes. Realizando una instalación típica del producto, las características básicas se presentan de la siguiente forma:

• En la parte superior aparecen tres elementos, en este orden: la barra de título donde figura el nombre del proyecto en curso y su estado (diseño o ejecución); la barra de menú con 13 opciones desplegables y una barra de herramientas; esta última se puede personalizar, posibilitando la inclusión de prácticamente la totalidad de los comandos del IDE.

• En la parte central, cubriendo la franja de mayor área, se encuentra el espacio de trabajo. Éste incluye y muestra las ventanas del proyecto, las vistas del código fuente de los módulos, los objetos y los controles que contienen las ventanas de la aplicación y el panel de controles.

• El panel de controles, que aunque es móvil normalmente está ubicado a la derecha, por defecto cuenta con los siguientes controles: - PictureBox: Caja de imágenes - Label: Etiqueta - TextBox: Caja de texto - Frame: Marco - CommandButton: Botón de comando - CheckBox: Casilla de verificación - OptionButton: Botón de opción - ComboBox: Lista desplegable - ListBox: Lista - HScrollBar: Barra de desplazamiento horizontal - VScrollBar: Barra de desplazamiento vertical - Timer: Temporizador - DriveListBox: Lista de unidades de disco - DirListBox: Lista de directorios - FileListBox: Lista de archivos - Shape: Figura - Line: Línea



- Image: Imagen - Data: Conexión a origen de datos - OLE: Contenedor de documentos embebidos compatibles con Object

Linking and Embedding

Además de los listados, se pueden agregar todo tipo de controles de terceros, y hay una gran cantidad de ellos que se proveen con el propio Visual Basic 6.0. Los controles vienen embebidos dentro de archivos con extensión OCX.

• Las ventanas de proyecto, aunque móviles, se encuentran en el panel lateral derecho y contienen dos vistas principales:

- El Explorador de proyectos, que muestra todos los elementos que componen el proyecto o grupos de proyectos (formularios, interfaz de controles, módulos de código, módulos de clase, etc.).

- El Panel de propiedades, donde se muestran todos los atributos de los objetos, controles, formularios, información de módulos clase, entre muchos otros.

• La Ventana inmediato, por defecto se encuentra en la parte inferior, aunque puede no estar visible (se presionan las teclas Ctrl+G, en ese caso, para mostrar la ventana). Esta ventana resulta una herramienta muy útil a la hora de depurar el programa o bien para realizar pruebas rápidas, ya que permite imprimir mensajes de texto desde el código y ejecutar sentencias y comandos simples inmediatamente (sólo sentencias que se puedan escribir en una sola línea). Por ejemplo, de la aplicación en curso, se puede consultar el valor de una variable o llamar a un método declarado en el módulo que se está depurando. Se puede ejecutar código "al vuelo", por ejemplo con sentencias como:

? sqr(2)

Siendo el signo ? un reemplazo natural del comando Print en Basic, al ejecutar la sentencia se mostraría por pantalla el valor de la raíz cuadrada de 2. También se pueden usar variables del propio programa, o sentencias de código tales como:

Msgbox "Prueba de cuadro de mensaje de error.", vbCritical, "Título del mensaje"

A la hora de la depuración puede ser útil para consultar el valor de variables del programa, o el código de error como:

? Err.Number

Objetos y eventos.



Se designa como objeto cualquier elemento, por ejemplo, un formulario, una imagen, un control, tal como una caja de texto; a su vez, los objetos tienen propiedades, que en el caso de la caja de texto una es la propiedad "text" que se encarga de contener el texto que aparecerá en la caja. A los objetos se les puede asociar eventos. Un evento es la ocurrencia de un suceso, comúnmente la acción que realiza el usuario sobre el objeto, que como resultado puede, por ejemplo, provocar un cambio en alguna propiedad de un objeto. Por ejemplo: Visual Basic tiene un evento llamado KeyPress, que ocurre cuando el usuario presiona una tecla; ese evento se puede asociar a la caja de texto, y en él definirá (por programación) qué acción se tomará cuando se oprima una tecla.

En síntesis, un objeto posee propiedades, responde a eventos y puede ejecutar métodos asociados a él.

Algunos eventos comunes definidos en Visual Basic son:

• Click: ocurre cuando se presiona y suelta un botón del mouse sobre un objeto.

• DblClick: ocurre cuando se presiona y suelta dos veces un botón del mouse sobre un objeto.

• DragDrop: ocurre al arrastrar y soltar un determinado objeto con el mouse. • DragOver: ocurre si una operación de arrastrar y soltar está en curso. • GotFocus: ocurre cuando un objeto recibe el control o foco, ya sea mediante

una acción del usuario como hacer click en un objeto ventana, o cambiando el foco de objeto desde el programa, mediante el método SetFocus.

• LostFocus: contrario al anterior, este evento ocurre cuando el objeto pierde el enfoque, sea mediante acción del usuario o efectuado desde la aplicación.

• KeyDown: ocurre cuando el usuario mantiene presionada una tecla. • KeyUp: ocurre cuando el usuario deja de presionar una tecla. Este evento

sucede precisamente al terminar el evento KeyDown. • KeyPress: ocurre como cuando se presiona y suelta una tecla. • MouseDown: ocurre cuando el usuario presiona un botón del mouse. • MouseUp: se produce cuando el usuario suelta el botón del mouse. • MouseMove: este evento ocurre mientras el usuario mueve o desplaza el

puntero del mouse sobre un objeto.

Imagínese un auto como un objeto; el auto tiene diversas propiedades como color, modelo, etc. Algunas con sólo 2 posibles valores, como encendido y apagado, incluso otras que a simple vista no se ven, como podría ser la cantidad de gasolina. Para definir el color de este objeto Auto, según Visual Basic, se haría de la siguiente manera:

Auto.color = rojo



y para definirle un evento podría ser como el siguiente ejemplo:

Sub girarllave( ) Auto.encendido=true end sub.

Ejemplo de código

El siguiente fragmento de código muestra un cuadro de mensaje, en una ventana, que dice "¡Hola, mundo!":

Private Sub Form_Load() MsgBox ("¡Hola, mundo!") End Sub

Ventajas:

• Posee una curva de aprendizaje muy rápida. • Integra el diseño e implementación de formularios de Windows. • Permite usar con facilidad la plataforma de los sistemas Windows, dado que

tiene acceso prácticamente total a la API de Windows, incluidas librerías actuales.

• Es uno de los lenguajes de uso más extendido, por lo que resulta fácil encontrar información, documentación y fuentes para los proyectos.

• Fácilmente extensible mediante librerías DLL y componentes ActiveX de otros lenguajes.

• Posibilita añadir soporte para ejecución de scripts, VBScript o JScript, en las aplicaciones mediante Microsoft Script Control.

• Tiene acceso a la API multimedia de DirectX (versiones 7 y 8). También está disponible, de forma no oficial, un componente para trabajar con OpenGL 1.1.

• Existe una versión, VBA, integrada en las aplicaciones de Microsoft Office, tanto Windows como Mac, que permite programar macros para extender y automatizar funcionalidades en documentos, hojas de cálculo y bases de datos (Access).

• Si bien permite desarrollar grandes y complejas aplicaciones, también provee un entorno adecuado para realizar pequeños prototipos rápidos.

Inconvenientes:

Las críticas hechas en las ediciones de Visual Basic anteriores a VB.NET son variadas; se citan entre ellas:

• Problema de versionado asociado con varias librerías runtime DLL, conocido como DLL Hell.

• Soporte pobre para programación orientada a objetos.



• Incapacidad para crear aplicaciones multihilo, sin tener que recurrir a llamadas de la API de Windows.

• Dependencia de complejas y frágiles entradas de registro COM

1. Ingrese por teclado un numero, calcule y visualice: a) El doble del número ingresado. b) La tercera parte del número ingresado. c) El cubo del número ingresado

2. Ingrese por teclado un numero de 3 cifras, calcule y visualice:

a) La suma de sus cifras b) Promedio de las cifras

Ejercicios y tareas de investigación



II. DIFERENCIAR LA PROGRAMACIÓN POR CONSOLA Y CON FORMULARIOS.


Definición de un proyecto en Visual Net Elaborar programa en modo consola Diseñar y programar un formulario


Computadora con microprocesadores core 2 Duo ó de mayor capacidad.



Definición de un proyecto en Visual Net Elaborar programa en modo consola Diseñar y programar un formulario

02

" Un fracaso es sólo una cicatriz, un mapa hacia la victoria...”……. ANONIMO.



2.1. DEFINICIÓN DE UN PROYECTO EN VISUAL NET.

Para iniciar la codificación en Visual Net 2010 seguimos los siguientes pasos:

1) En inicio ejecutar escribir DEVENV

Comenzará a cargar el programa

2) En FILE NEW PROYECT

1

2



3) Elegir la opción CONSOLE APPLlCATION.

4) Escribimos el nombre del proyecto

5) Seguidamente pulsamos OK.

Por defecto se tiene el modulo:

En esta sección dentro del main se va codificar el

algoritmo

3

4 5



2.2. ELABORAR PROGRAMA EN MODO CONSOLA.

Ejemplo:

1.- Calcular el área de un triángulo.

Imports System.Console Imports System.Math Module Module1

Sub Main() Dim b,h As Integer Dim area As Double

Write(“Ingresar la base….:”) b=ReadLine() Write(“Ingresa la altura…”) h=ReadLine() área=(b*h)/2 WriteLine(“El área es…:” & área) ReadLine()

End Sub End Module

Ejecutamos la aplicacion hacienda clic en Start Debugging o usando la tecla de función F5.

Visualizaremos el programa en modo consola

Ingresamos los datos de los lados del triangulo y Enter



2.- Ingrese por teclado un número de dos cifras, visualice su número invertido.

Imports System.Console Imports System.Math Module Module2 Sub Main() Dim número, inverso, unidad, decena As Integer Write("Ingresa un número de 2 cifras….:") número = ReadLine() unidad = número Mod 10 decena = número \ 10 inverso = 10 * unidad + decena WriteLine("El número invertido es…:" & inverso) ReadLine() End Sub End Module

3.- Ingrese por teclado un número de 3 cifras, visualice la suma de las cifras del número ingresado.

Imports System.Console Imports System.Math Module Module3 Sub Main() Dim número, unidad, decena, centena, suma As Integer Write("Ingresa un número de 3 cifras...:") número = ReadLine() unidad = número Mod 10



decena = (número \ 10) Mod 10 centena = número \ 100 suma = unidad + decena + centena WriteLine("La suma de cifras es...:" & suma) ReadLine() End Sub End Module

4.- Una empresa dedicada a la venta de electrodomesticos, realiza una promocion del 20 % + 15 % de descuento. Ingrese el nombre y precio de un electrodoméstico, calcule y visualice su descuento y el neto a pagar.

Imports System.Console Imports System.Math Module Module3 Sub Main() Dim nombre, precio, descuento1, descuento2, neto As Double Write("Ingresa el número del electrodomestico...:") nombre= ReadLine() Write("Ingresa el número del electrodomestico...:") precio= ReadLine() descuento1= precio * 0.20 descuento2= (precio – descuento) * 0.15 neto = precio – (descuento1 + descuento2) WriteLine("El precio del " & nombre && “y su precio es “& neto) ReadLine() End Sub End Module



Trabajar con constantes y variables.

Variables:

Es un espacio en la memoria de la computadora que permite almacenar temporalmente un dato durante la ejecución de un proceso, su contenido puede cambiar durante la ejecución del programa.

Para poder reconocer una variable en la memoria de la computadora, es necesario darle un nombre con el cual podemos identificarla dentro de un algoritmo.

Su valor puede ser modificado, pero en un instante dado solo contiene un valor determinado.

Declaración:

Las variabloes pueden asumir valores numéricos, carácter y lógicos.

Existen 2 tipos de duración o ámbito de las variables estas son (global y local)

Las variables globales se pueden utilizar en cualquier parte del algoritmo.

Las variables locales son dentro de un sub-programa (procedimiento o función)

Ejm:

DECLARACION:

ABC VALIDO

A123 VALIDO

1A2B NO VALIDO

_MiVariable VALIDO

Mi_Variable VALIDO

Mi@Variable NO VALIDO



Clasificacion de las Variables:

Numericas

Por su contenido Logicas

Alfanumericas

Variables

Del trabajo

Por su Uso Contadores

Acumuladores

Declaracion:

Para declarar variables en un algoritmo se hace uso de la siguiente sintaxis:

Tipo_Dato: Lista_Variables

Ejemplos:

ENTERO: A, B, C

REAL: X, Y, Z

CARÁCTER: Car1, Car2

CADENA: Texto1, Texto2

LOGICO: Estado, Ok, Done

En visual las analogías son:

DIM, VAR1, VAR2 AS TIPO

Seudocódigo Visual

Entero Integer

Entero largo Long

Real Doublé

Carácter Char

Cadenas String



CONSTANTES:

Objeto de datos que contiene un valor invariable conocido por su identificador.

Es necesario inicializar las constantes al principio del algoritmo. Eso determina el tipo de constante.

Ejemplos

PI=3,14

SALUDO=”HOLA MUNDO”

MAXIMO=500

RESPUESTA=’S’

Analizar la importancia de una estructura condicional.

ESTRUCTURA CONDICIONAL.

Las estructuras condicioanles también reciben el nombre de estructuras de selección”, permite elegir entre diferentes cursos de acción en función de condiciones.

Las estructuras condicionales comparan una variable contra otro(s) valor(es), para que en base al resultado de esta comparación, se siga un curso de acción dentro del programa. Cabe mencionar que la compracion se puede hacer contra otra variable o contra una constante, según se necesite.

En una estructura condicional se evalua una expresión lógica y dependiendo del resultado se ejecutan una sentencias u otras.

Clasificacion:

Las estructuras condicionales o selectivas se clasifican en:

1. Condicional Simple (SI / FIN-SI) 2. Condicional Doble (SI / SINO / FIN-SI) 3. Condicional Anidada (SI / SINO / FIN-SI) 4. Condicional Multiple (EN_CASO / FIN-EN_CASO)

Estrucutura Condicional Simple

Es aquella estructura de control que evalua una condición:

Si la condición se cumple se ejecutan determinadas acciones.

Si la condición no se cumple, no se ejecutan esas acciones



SINTAXIS:

DIAGRAMA DE FLIJO

PSEUDOCÓDIGO

Si <condicion> entonces

<consecuencias>

Fin si

EJERCICIOS.

Ingrese por teclado 2 numeros enteros y visualice el mayor de los 2 numeros ingresados

ALGORITMO Ejemplo1

VARIABLES

ENTERO: A, B, Mayor

INICIO

LEER (A,B)

Mayor A

SI (B > A) ENTONCES

Mayor B

FIN-SI

ESCRIBIR (Mayor)

FIN

CONDICION

CONSECUENCIAS

SI

NO



CODIFICACION EN VISUAL A NIVEL DE CONSOLA.

Imports System.Console Imports System.Math Module Module1 Sub Main() Dim A, B, Mayor As Integer Write("Ingrese el valor 1...:") A = ReadLine() Write("Ingrese el valor 2...:") B = ReadLine() Mayor = A IF B > A THEN Mayor = B END IF WriteLine("El mayor es...:" & mayor) ReadLine() End Sub End Module

Ingrese por teclado un numero entero, si es mayor a 10 sumele 10 unidades y visualice el nuevo valor.

ALGORITMO Ejemplo2

VARIABLES

ENTERO> N

INICIO

LEER (N)

SI ( N > 10 ) ENTONCES

N N + 10

FIN-SI

ESCRIBIR (N)

FIN



Codificacion en visual a nivel de consola.

Imports System.Console Imports System.Math Module Module2 Sub Main() Dim N As Integer Write("Ingrese el valor 1...:") A = ReadLine() IF N > 10 THEN N = N + 10 END IF WriteLine("El nuevo es...:" & N) ReadLine() End Sub End Module

Ingrese por teclado la edad de una persona; si su edad es mayor a 17, visualice un mensaje “Es mayor de Edad”.

ALGORITMO Ejemplo3

VARIABLES

ENTERO: edad

INICIO

LEER (edad)

SI (edad > 17 ) ENTONCES

ESCRIBIR “Es mayor de edad”

FIN-SI

FIN

Imports System.Console Imports System.Math Module Module3



Sub Main() Dim edad As Integer Write("Ingrese su edad...:") edad = ReadLine() IF edad > 17 THEN WriteLine("Eres mayor de edad”) END IF ReadLine() End Sub End Module

Ingrese por teclado la talla de una persona; visualice un mensaje “Servicio Obligatorio”, si tiene un talla minima de 1.70 metros

ALGORITMO Ejemplo4

VARIABLES

REAL: talla

INICIO

LEER (talla)

SI (talla >=1.70) ENTONCES

ESCRIBIR “Servicio Obligatorio”

FIN-SI

FIN

Codificación en visual a nivel de consola. Imports System.Console Imports System.Math Module Module4 Sub Main() Dim talla As double Write("Ingrese su edad...:")



talla = ReadLine() IF talla> 1.70 THEN WriteLine("Servicio Obligatorio”) END IF ReadLine() End Sub End Module Ejemplos de programas en consola.

Ejemplo 01:

Programar el método Main para interactuar con el usuario, pedirle la fecha, y encargarnos que la introduzca correctamente

Codigo:

private static void Main(string[] args) { //Variables que usaremos para la fecha de nacimiento int dia_nacimiento, mes_nacimiento, año_nacimiento=0; Console.WriteLine("Escriba su nombre"); string nombre = Console.ReadLine(); Console.WriteLine("Hola {0}, bienvenido a mi aplicacion!",nombre); Console.WriteLine("Por favor, introduce tu fecha de nacimiento:"); //El while solo termina cuando se hace break while (true) { //Pedimos el dia y lo validamos Console.Write("Dia de nacimiento: "); dia_nacimiento = int.Parse(Console.ReadLine()); if (dia_nacimiento < 1 || dia_nacimiento > 31) Console.WriteLine("Por favor, especifique un dia entre 1 y 31"); else //Si el dia es valido, entonces pasamos a pedir el mes break; } while (true) { //Pedimos el mes y lo validamos Console.Write("Mes de nacimiento: "); mes_nacimiento = int.Parse(Console.ReadLine());



if (mes_nacimiento < 1 || mes_nacimiento > 12) Console.WriteLine("Por favor, especifique un mes entre 1 y 12"); else break; } while (true) { //Pedimos el año y lo validamos Console.Write("Año de nacimiento: "); año_nacimiento = int.Parse(Console.ReadLine()); //El año no puede ser posterior a 1900 y anterior al año actual if (año_nacimiento < 1900 || año_nacimiento > DateTime.Now.Year) Console.WriteLine("Por favor, especifique un año entre 1900 y el {0}", DateTime.Now.Year); else break; } //Si llegamos aqui, es porque tenemos una fecha correcta, vamos a calcular la edad con //el método DameEdad() que escribimos antes int edad = DameEdad(dia_nacimiento, mes_nacimiento,año_nacimiento); Console.WriteLine(nombre+", usted tiene " + edad + " años."); Console.WriteLine("Presione cualquier tecla para terminar el programa"); Console.ReadKey(); }

Ejemplo 02:

Area de un rectángulo

Código:

using System; using System.Collections.Generic; using System.Text; namespace Area_de_un_rectangulo { class Program { static void Main(string[] args) { //Area de un regtangulo CristianAbelardo float Base; float Altura;



float Area; Console.WriteLine("Area de un Regtangulo"); Console.WriteLine(); Console.WriteLine("ingrese la base"); Base=float.Parse(Console.ReadLine()); Console.WriteLine("Ingrese la altura"); Altura=float.Parse(Console.ReadLine()); Console.WriteLine(); Console.WriteLine(); //Procesando datos Area = Base * Altura; Console.WriteLine("El rectangulo de base {0} y altura {1} tiene un area de {2}", Base, Altura, Area); Console.ReadLine(); } } }

Ejemplo 03:

Conversor de Pies a Metros

Codigo:

using System; using System.Collections.Generic; using System.Text; namespace Convertir_pies_a_metros { class Program { static void Main(string[] args) { //conversor pies a metros by cristianabelardo //segun google 1 pie = 0,3048 metros //1 metro = 3,2808399 pies float Pie; float Metro; float Medida; Medida=3.280839F; Console.WriteLine("Conversor de medidas"); Pie = float.Parse(Console.ReadLine());



//procesando datos Metro = Pie * Medida; Console.WriteLine("{0} Pies es igual a {1}",Pie ,Metro); Console.ReadLine(); } } }

Ejemplo 04: Sumatoria de los N primeros numeros pares [Sin estructura repetitiva] Código: using System; using System.Collections.Generic; using System.Text; namespace Sumatoria_Numeros_Pares { class Program { static void Main(string[] args) { //CristianAbelardo int NPares; int Sumatoria; Console.WriteLine("Sumatoria de los N primeros Numeros Pares"); Console.WriteLine("Ingrese N"); NPares=int.Parse(Console.ReadLine()); //Procesar Sumatoria = NPares*(NPares + 1); Console.WriteLine("La sumatoria de los primeros {0} numeros pares es {1}",NPares, Sumatoria ); Console.ReadLine(); }



} }

Ejemplo 05:

Cajero automatico Calcula la cantidad minima de billetes para la cantidad solicitadae indica la cantidad de cada billete o moneda El programa esta en "Soles"

Código: using System; using System.Collections.Generic; using System.Text; namespace Cajero_Automatico { class Program { static void Main(string[] args) { //CristianAbelardo //Cajero automatico //Entrega el dinero solicitado en la cantidad minima de billetes int CantidadDinero; int Billetes200; int Billetes100; int Billetes50; int Billetes20; int Billetes10; int Monedas5; int Monedas2; int Monedas1; int Residuo; int Resultado; Console.WriteLine("Ingrese la Cantidad de Dinero que desea retirar"); CantidadDinero = int.Parse(Console.ReadLine()); // Procesamineto Billetes200 = CantidadDinero / 200; Residuo = CantidadDinero % 200;



Billetes100 = Residuo / 100; Residuo=Residuo%100; Billetes50 = Residuo / 50; Residuo = Residuo % 50; Billetes20 = Residuo / 20; Residuo = Residuo % 20; Billetes10 = Residuo / 10; Residuo = Residuo % 10; Monedas5 = Residuo / 5; Residuo=Residuo%5; Monedas2 = Residuo / 2; Residuo = Residuo % 2; Monedas1 = Residuo / 1; Residuo = Residuo % 1; //Cantifad minima de billetes Resultado = Billetes200 + Billetes100 + Billetes50 + Billetes20 + Billetes10 + Monedas5 + Monedas2 + Monedas1; //Mostrar resultados Console.Clear(); Console.WriteLine("Dinero Solicitado : {0}", CantidadDinero); Console.WriteLine("Billetes de 200 : {0}",Billetes200 ); Console.WriteLine("Billetes de 100 : {0}", Billetes100); Console.WriteLine("Billetes de 50 : {0}", Billetes50); Console.WriteLine("Billetes de 20 : {0}", Billetes20); Console.WriteLine("Billetes de 10 : {0}", Billetes10); Console.WriteLine("Monedas de 5 : {0}",Monedas5 ); Console.WriteLine("Monedas de 2 : {0}", Monedas2); Console.WriteLine("Monedas de 1 : {0}", Monedas1); Console.WriteLine("La cantidad Mimima de"); Console.WriteLine("Billetes y monedas es:{0}", Resultado); Console.WriteLine(""); Console.ReadLine(); }



} }

2.3. DISEÑAR Y PROGRAMAR UN FORMULARIO.

Para el diseño de formularios:

Para crear un formulario nuevo

1. En el Administrador de proyectos, elija la ficha Documentos. 2. Seleccione el icono Formularios. 3. Elija Nuevo. 4. Seleccione Nuevo formulario. Aparecerá la ventana Diseñador de

formularios, en la que podrá comenzar a crear el formulario.

–O bien–

• En el menú Archivo, elija Nuevo, seleccione Formulario y, a continuación, elija Nuevo archivo.

–O bien–

• Utilice el comando CREATE FORM.

Modificar formularios

Si los formularios creados mediante el asistente o el generador no se adaptan a sus necesidades, puede modificarlos con el Diseñador de formularios. Con este diseñador resulta fácil mover y cambiar el tamaño de los controles, copiar o eliminar controles, alinear controles y modificar el orden de tabulación.

Para modificar un formulario ya generado.

1. En el Administrador de proyectos, seleccione la ficha Documentos. 2. Elija el icono Formularios y seleccione el nombre del formulario. 3. Elija Modificar.

Agregar campos rápidamente

Si desea situar rápidamente los campos de una tabla o una vista en un formulario, elija el comando Formulario rápido del menú Formulario. Este comando iniciará el Generador de formularios, que agregará los campos seleccionados desde la tabla o la vista al formulario, empleando el estilo de campo que elija. El Generador de formularios crea un formulario sin controles de desplazamiento, de forma que pueda agregar los que desee. Puede utilizar


http://msdn.microsoft.com/es-es/library/cc467858%28v=vs.71%29.aspx





un generador de controles para agregar controles al formulario o elegirlos en la biblioteca de controles de desplazamiento predefinidos que se suministra con Visual FoxPro.

Para agregar campos a un formulario

1. En el Administrador de proyectos, abra el formulario. 2. En el Diseñador de formularios vaya al menú Formulario y elija Formulario

rápido. Aparecerá el Generador de formularios. 3. En la ficha Estilo, seleccione el estilo que desea para el nuevo control. 4. En la ficha Seleccionar campos, seleccione el origen de los campos y los

campos que desea agregar. 5. Haga clic en Aceptar para generar el formulario.

–O bien–

6. En la barra de herramientas Controles de formularios, elija un control de datos y arrástrelo a la ventana Diseñador de formularios para crear el control.

7. En la ventana Propiedades, elija la ficha Datos y seleccione la propiedad ControlSource.

8. Introduzca un nombre de campo.

Crear una aplicación de formularios Windows Forms.

En e l me nú Archivo, haga clic en Nuevo proyecto.

Aparecerá el cuadro de diálogo Nuevo proyecto. En este cuadro de diálogo se muestra la lista de los diferentes tipos de aplicación predeterminados que puede crear Visual C# Express.

Seleccione Aplicación de Windows Forms como tipo de proyecto.

Ca mbie e l nombre de la a plica ción a Explorador web.

Ha ga clic e n Aceptar.

Visual C# Express crea una nueva carpeta para el proyecto con el nombre del título del proyecto y, a continuación, muestra el nuevo formulario Windows Forms titulado Form1 en la vista Diseñador. Puede alternar entre esta vista y la vista Código en cualquier momento si hace clic con el botón secundario del mouse en la superficie de diseño o en la ventana de código y selecciona Ver código o Ver diseñador.





El formulario Windows Forms que se ve en la vista Diseñador es una representación visual de la ventana que se abrirá al abrir la aplicación. En la vista Diseñador, puede arrastrar diversos controles desde el Cuadro de herramientas hasta el formulario. Estos controles no están realmente "activos"; son sólo imágenes que se pueden mover sin problemas por el formulario hasta ocupar un lugar preciso.

Una vez colocado un control en el formulario, Visual C# funciona en segundo plano para crear el código que hará que el control real ocupe la posición correcta cuando se ejecute el programa. Este código fuente se encuentra en un archivo que, generalmente, permanece anidado fuera de la vista. Puede ver este archivo, denominado Form1.designer.cs, en el Explorador de soluciones si expande Form1.cs.

S i e s tá e n la vis ta Código, cambie a la vista Diseñador haciendo clic con el botón secundario del mouse en la ventana de código y, a continuación, haciendo clic en Ver diseñador. Ahora, cambie el tamaño del formulario Windows Forms.

1. Haga clic en la esquina inferior derecha del formulario Windows Forms. 2. Cuando el puntero se convierta una flecha de dos puntas, arrastre la esquina

del formulario hasta que sea por lo menos tan ancho y profundo como un cuarto de su pantalla.

Puesto que ésta es la ventana en la que aparecerán las páginas web, será mejor que no quede demasiado reducida.

As e gúre s e de que s e mue s tra la ventana Propiedades. Su ubicación predeterminada es la sección inferior derecha del IDE, pero puede moverla a



otra ubicación si lo desea. La ilustración siguiente la muestra en la esquina superior derecha. Si la ventana Propiedades no está visible, en el menú Ver haga clic en Ventana Propiedades. Esta ventana muestra las propiedades del control o formulario Windows Forms seleccionado y en ella se pueden cambiar los valores existentes.

Ca mbie e l título de l formula rio Windows Forms .

1. Haga clic en el formulario para seleccionarlo. 2. En la ventana Propiedades, desplácese hacia abajo hasta Text, seleccione

el texto "Form1" y escriba Explorador web. 3. Presione ENTRAR o TAB para desplazar el foco del cuadro de texto "Text".

Ahora verá que el texto situado en la parte superior del formulario Windows Forms (en el área denominada barra de título) ha cambiado.

Para cambiar rápidamente el nombre de un control, haga clic con el botón secundario del mouse en el control y haga clic en Propiedades. Puede escribir el nuevo nombre para el control en la propiedad Name.

Ha ga clic e n e l botón Cuadro de herramientas de la barra de herramientas, o bien, haga clic en Cuadro de herramientas en el menú Ver. Desplácese hacia abajo por la lista de controles y expanda Menús y barras de herramientas hasta que vea MenuStrip. Arrastre este control a cualquier lugar del formulario Windows Forms.


http://msdn.microsoft.com/es-es/library/system.windows.forms.menustrip%28v=vs.90%29.aspx


Este control crea un menú predeterminado en la parte superior del formulario.

En e l cua dro que dice Escriba aquí, escriba el nombre del menú, en este caso Navegar. Cuando presione ENTRAR, aparecerán nuevos cuadros vacíos para crear otros menús y elementos de menú. En el cuadro inferior, escriba Inicio. Presione ENTRAR y aparecerán más cuadros. Escriba Hacia atrás. Presione ENTRAR y escriba Hacia delante.

Estos elementos de menú forman los controles de navegación básicos del sitio Web.



Agre gue un botón.

En el Cuadro de herramientas, en la categoría Controles comunes, arrastre un control Button hasta aproximadamente la mitad del formulario Windows Forms, justo debajo de la barra de menús. En la ventana Propiedades, cambie la propiedad Text a Ir en lugar de button1, y cambie el nombre del diseño, que se muestra como (Nombre), de button1 a BotonIr.

Sintaxis en C#

[ComVisibleAttribute(true)] [ClassInterfaceAttribute(ClassInterfaceType.AutoDispatch)] public class Button : ButtonBase, IButtonControl

Agre gue un control ComboBox.

En el Cuadro de herramientas, en la categoría Controles comunes, arrastre un control ComboBox y colóquelo a la izquierda del nuevo botón. Arrastre los bordes y las esquinas para cambiar el tamaño y la posición del control ComboBox hasta que quede alineado con el botón. Sintaxis en C# [ClassInterfaceAttribute(ClassInterfaceType.AutoDispatch)] [DefaultBindingPropertyAttribute("Text")] [ComVisibleAttribute(true)] public class ComboBox : ListControl Nota: Cuando mueva los controles en un formulario Windows Forms, verá aparecer líneas azules. Estas líneas son guías que ayudan a alinear los controles en dirección vertical y horizontal. También puede alinear controles seleccionando más de uno a la vez. Para ello, haga clic y arrastre un cuadro de selección alrededor de los controles, o mantenga presionada la tecla MAYÚS mientras hace clic en ellos. Después de tener varios controles seleccionados, puede modificar la alineación y el tamaño utilizando los iconos de alineación y cambio de tamaño. Estos iconos aparecen en la Barra de herramientas de diseño, en la parte superior de la ventana Diseño.


http://msdn.microsoft.com/es-es/library/system.windows.forms.button%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/system.windows.forms.combobox%28v=vs.90%29.aspx


Re lle ne e l control ComboBox.

Un control ComboBox proporciona una lista desplegable de opciones entre las que el usuario puede seleccionar. En este programa, el control ComboBox va a contener una lista de los sitios web favoritos para obtener un rápido acceso.

Para crear la lista de sitios, seleccione el control ComboBox y vea sus propiedades. Seleccione la propiedad Items; verá la palabra (Colección) y un botón puntos suspensivos (...). Haga clic en este botón para modificar el contenido del control ComboBox. Agregue tantas direcciones URL del sitio Web como desee, presionando RETORNO después de cada una.

Nota: Asegúrese de incluir http:// delante de cada una de las direcciones de sitio web. Agre gue e l control WebBrowser.

En el Cuadro de herramientas, en la categoría Controles comunes, desplácese hacia abajo hasta llegar al control WebBrowser. Arrastre el control hasta el formulario Windows Forms. Cambie el tamaño del control WebBrowser para ajustarlo al formulario Windows Forms sin ocultar los controles ComboBox y Button. Si el tamaño del control WebBrowser no se puede cambiar fácilmente, configure primero el tamaño deseado, abra las propiedades, busque el valor Dock y asegúrese de que está establecido en ninguno. Al establecer la configuración de Anchor en Superior, Inferior, Izquierda, Derecha, el control WebBrowser cambiará su tamaño correctamente cuando se cambie el tamaño de la ventana de la aplicación.

El control WebBrowser realiza todo el trabajo difícil de representación de páginas Web. El acceso a este control en la aplicación se realiza a través de una instancia de la clase WebBrowser. Observe form1.Designer.cs y verá que se ha agregado una instancia de esta clase al código de la aplicación, junto con instancias de clases que representan los demás elementos que se han agregado utilizando el diseñador. Estas son las instancias que utilizará cuando agregue controladores de eventos para los controles y llame a los métodos de los citados controles.

Sintaxis en c# [ComVisibleAttribute(true)] [ClassInterfaceAttribute(ClassInterfaceType.AutoDispatch)] [DockingAttribute(DockingBehavior.AutoDock)] [PermissionSetAttribute(SecurityAction.InheritanceDemand, Name = FullTrust")]







http://msdn.microsoft.com/es-es/library/system.windows.forms.webbrowser%28v=vs.90%29.aspx






http://msdn.microsoft.com/es-es/library/system.windows.forms.control.dock%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/system.windows.forms.control.anchor%28v=vs.90%29.aspx





[PermissionSetAttribute(SecurityAction.LinkDemand, Name = "FullTrust")] public class WebBrowser : WebBrowserBase

Agre gue un controla dor de e ve ntos pa ra e l control Button.

Ya ha terminado la etapa de diseño de la aplicación y ahora puede empezar a agregar código para proporcionar la funcionalidad del programa.

El programa debe tener los controladores de eventos para el botón y para cada opción de menú. Un controlador de eventos es un método que se ejecuta cuando el usuario interactúa con el control. Visual C# Express crea automáticamente controladores de eventos vacíos.

Haga doble clic en el botón y verá aparecer el Editor de código para el proyecto. También verá que se ha creado el controlador para el evento Click, que es el mensaje que aparece cuando el usuario hace clic en un botón. Agregue código al método del controlador de eventos de modo similar al siguiente código.

C#

private void goButton_Click(object sender, System.EventArgs e) { webBrowser1.Navigate(new Uri(comboBox1.SelectedItem.ToString())); }

Este código toma el elemento seleccionado del control ComboBox, una cadena que contiene una dirección URL web, y lo pasa al método Navigate del explorador web. El método Navigate se carga y muestra el contenido de la página Web en esa ubicación.

Agre gue controla dore s de e ve ntos pa ra la s opcione s de MenuStrip.

Vuelva a la ventana Diseñador y haga doble clic en los subelementos del menú de uno en uno. Visual C# Express creará métodos de control de eventos para cada uno. Edite estos métodos, de modo que se asemejen al código siguiente.

C#

private void homeToolStripMenuItem_Click(object sender, System.EventArgs e) { webBrowser1.GoHome(); }



http://msdn.microsoft.com/es-es/library/system.windows.forms.webbrowser.navigate%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/system.windows.forms.menustrip%28v=vs.90%29.aspx


private void goForwardToolStripMenuItem_Click(object sender, System.EventArgs e) { webBrowser1.GoForward(); } private void goBackToolStripMenuItem_Click(object sender, System.EventArgs e) { webBrowser1.GoBack(); }

Cada uno de estos controladores de menú llama a un método de navegación admitido en la clase WebBrowser.

Nota: A partir de este código, puede ver que los nombres predeterminados dados a las opciones de menú pueden resultar muy confusos. Por esta razón, es una buena idea cambiar el nombre de cada control de menú al crearlo mediante el editor de Propiedades. El nombre del controlador reflejará entonces el nombre de la opción de menú.

Ve a e l código que Vis ua l C# ha e s crito a utomá tica me nte .

El IDE de Visual C# ya ha escrito código de inicialización. En la vista Código, busque el constructor de la clase Form1. Tiene una firma de public Form1(). Haga clic con el botón secundario del mouse en el método InitializeComponent al que se llama desde dentro del constructor y, a continuación, haga clic en Ir a definición. Ahora verá todo el código que se iba escribiendo en segundo plano mientras arrastraba y colocaba controles y establecía propiedades en la ventana Propiedades.

Agregue código de inicialización propio.

La última tarea es agregar su propio código de inicialización a Form1. El constructor nunca debe utilizarse para llamar a código que pueda producir una excepción. Por consiguiente, cualquier código de este tipo se debe colocar en otra parte; ese lugar es el método Form1_Load. Haga clic en la ficha Form1.cs [Diseño] en la parte superior del editor de código para regresar al formulario Windows Forms. Seleccione el formulario y, en la ventana Propiedades, haga clic en el botón Eventos (el que tiene un icono de rayo) y, a continuación, haga doble clic en Cargar. Esto agregará un método de control de eventos y colocará el cursor en el método en la vista Código.




Cuando un usuario final inicie el programa, Windows notificará este hecho al formulario de la aplicación enviando un evento Load. Cuando el formulario reciba ese evento, llamará al método Form1_Load. Los métodos a los que se llama en respuesta a eventos se denominan controladores de eventos. El sistema llamará al evento en el momento adecuado; ahora tiene que colocar el código en el controlador de eventos que desee que se ejecute cuando se produzca el evento.

En la vista Código, agregue dos líneas al método Form1_Load, como se muestra a en el siguiente código. Esto hará que el control WebBrowser muestre la página principal predeterminada del equipo y establezca el valor inicial del control ComboBox.

C#

private void Form1_Load(object sender, EventArgs e)

{

comboBox1.SelectedIndex = 0;

webBrowser1.GoHome();

}

Genere y ejecute el programa.

Presione F5 para generar y ejecutar el explorador web. Se mostrará en pantalla el formulario Windows Forms creado y, a continuación, aparecerá la página principal predeterminada del equipo. Puede utilizar el control ComboBox para seleccionar un sitio web, y hacer clic en Ir para navegar al mismo. Las opciones de menú permiten volver a la página principal o desplazarse hacia delante y hacia atrás a través de los sitios Web visitados anteriormente.


http://msdn.microsoft.com/es-es/library/system.windows.forms.form.load%28v=vs.90%29.aspx





FUNDAMENTO TEÓRICO:

Definición de un proyecto en Visual Net. El proyecto es el punto de inicio para la creación de aplicaciones, componentes y servicios en Visual Studio 2008. El proyecto actúa como un contenedor que administra el código fuente, las conexiones de datos y las referencias. Un proyecto se organiza como parte de una solución, que puede contener múltiples proyectos dependientes entre sí. Los temas de esta sección describen las diferentes tareas relativas a la creación y la administración de proyectos de Visual Basic y Visual C#.

Administrar propiedades del proyecto con el Diseñador de proyectos

El Diseñador de proyectos es una útil interfaz de usuario de Visual Studio que le permite establecer las propiedades del proyecto, algunas de las cuales se pueden establecer también mediante la Propiedades (Ventana).

Proyectos locales y proyectos web

Hay varios factores que se deben considerar al decidir si se utiliza un modelo de proyecto local o proyecto Web para una aplicación.

En primer lugar, la estrategia de instalación debería formar parte de los factores que influyen en la decisión general. Si necesita una aplicación de rápida implementación en un servidor con una configuración de cliente mínima, el modelo de proyecto Web es el más recomendable. Se puede instalar y ejecutar este proyecto en un servidor sin instalar archivos de compatibilidad en cada cliente y realizar las actualizaciones sólo en un servidor. Sin embargo, para aquellos proyectos en los que el servidor no juegue un papel importante o para aplicaciones autónomas, la mejor opción es un modelo de proyecto local. En este escenario, las actualizaciones pueden completarse en cada equipo cliente individual.

Otro factor es la división de la carga de trabajo. Cuando analice el marco de trabajo de la aplicación, deberá considerar dónde se realizará la mayor parte del trabajo. Los proyectos Web ofrecen una estrategia basada en servidor, donde la mayoría de las operaciones se ejecutan en el servidor. El equipo cliente utiliza un explorador web para enviar y mostrar información procedente de la aplicación del lado del servidor. Si los recursos del servidor son limitados, considere la posibilidad de utilizar un modelo de


http://msdn.microsoft.com/es-es/library/ms171352%28v=vs.90%29.aspx



proyecto local para la aplicación. El trabajo puede realizarse en el equipo cliente sin consumir el valioso tiempo del servidor.

La tabla siguiente ofrece una comparación frente a frente entre los proyectos Web y los proyectos locales, tanto en el entorno de diseño como en el de trabajo:

Consideración Proyecto Web Proyecto local

Almacenamiento de archivos durante el desarrollo

Los archivos se almacenan en una dirección URL específica en un equipo que tiene instalado Internet Information Services (IIS). El proyecto mantiene también una memoria caché temporal de archivos en los equipos cliente para trabajar sin conexión.

Los archivos del proyecto se almacenan en el equipo local.

Modelo de generación durante el desarrollo

El código de la aplicación se compila en forma de biblioteca DLL y se ejecuta en el servidor. Los resultados se ven en el equipo cliente.

El código se compila y se ejecuta en el equipo cliente.

Método de implementación

El proyecto se implementa en un servidor Web.

Los archivos del proyecto se instalan en el equipo cliente con los archivos de compatibilidad requeridos.

Carga de trabajo

Los equipos cliente ejecutan la aplicación de forma remota con un explorador web. El procesamiento se realiza primero en el servidor.

La aplicación se ejecuta localmente en el equipo cliente.

Actualización

Las modificaciones de la aplicación se realizan en el nivel del servidor, sin instalar archivos de compatibilidad en los equipos cliente.

Las actualizaciones de la aplicación se instalan en los equipos cliente.

Traslado de archivos de proyecto

El comando Copiar proyecto se utiliza para mover archivos a la dirección URL especificada.

Los archivos del proyecto se copian físicamente de una ubicación a otra.

• Propiedades de archivo.

o Puede utilizar las propiedades de archivo para indicar qué acciones debe

ejecutar sobre los archivos el sistema del proyecto. Por ejemplo, puede establecer propiedades de archivo para indicar si un archivo debe compilarse o incrustarse en los resultados de la generación como recurso.

o Puede seleccionar cualquier archivo en el Explorador de soluciones y, a continuación, examinar sus propiedades en la ventana Propiedades. Los



archivos de Visual Basic y Visual C# tienen cuatro propiedades: FileName, BuildAction, CustomTool y CustomToolNamespace.

Nota: Las propiedades BuildAction, CustomTool y CustomToolNamespace se proporcionan para casos avanzados. Habitualmente, los valores predeterminados son suficientes y no es necesario cambiarlos.

FileName (Propiedad).

Puede cambiar el nombre de un archivo haciendo clic en la propiedad FileName en la ventana Propiedades y escribiendo el nuevo nombre. Observe que si cambia el nombre del archivo, Visual Studio cambiará automáticamente el nombre de los archivos .vb o .resx que estén asociados a él.

Propiedad BuildAction.

La propiedad BuildAction indica lo que hace Visual Studio con un archivo cuando se ejecuta una generación. BuildAction puede tener uno o numerosos valores:

• None: el archivo no está incluido en el grupo de resultados del proyecto, ni se compila en el proceso de generación. Un ejemplo es un archivo de texto que contenga documentación, como un archivo Léame.

• Compile: el archivo está compilado en el resultado de la compilación. Este valor se utiliza para los archivos de códigos.

• Contenido: el archivo no está compilado, pero se incluye en el grupo de resultados del contenido. Por ejemplo, este valor es el predeterminado de un archivo .htm o cualquier otro tipo de archivo Web.

• Recurso incrustado: este archivo está incrustado en el resultado de la generación del proyecto principal como un DLL o ejecutable. Este valor se utiliza normalmente para los archivos de recursos.

El valor predeterminado de BuildAction depende de la extensión del archivo que agregue a la solución. Por ejemplo, si agrega un proyecto de Visual Basic al Explorador de soluciones, el valor predeterminado de BuildAction es Compile. Esto se debe a que la extensión .vb indica que se trata de un archivo de código que se puede compilar. Los nombres y las extensiones de archivo aparecen en el Explorador de soluciones.

Observe que el nombre del archivo del proyecto no será el identificador para el recurso administrado en el manifiesto del ensamblado (vea Manifiesto del ensamblado para obtener más información). El identificador será espacio de nombres.nombre de archivo.extensión, donde espacio de nombres es el valor


http://msdn.microsoft.com/es-es/library/1w45z383%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/1w45z383%28v=vs.90%29.aspx


de la propiedad DefaultNamespace en un proyecto de Visual C# o la propiedad RootNamespace en un proyecto de Visual Basic. Nombre de archivo y extensión mantienen su designación original. Si el archivo es un archivo .resx, el sistema del proyecto ejecutará el resgen.exe en el archivo, creando un archivo de recursos. El archivo .resource se incrustará en el ensamblado. Por consiguiente, el manifiesto del ensamblado hará referencia al archivo .resources, y no al archivo .resx.

Por ejemplo, si agrega el archivo MyFile.bmp a un proyecto cuyo espacio de nombres predeterminado sea MyProj y establece la acción de generación en Recurso incrustado, MyProj.MyFile.bmp será el identificador en el manifiesto del ensamblado. Si posteriormente agrega el archivo MyFile.resx al proyecto, la acción de compilación predeterminada será Recurso incrustado y MyProj.MyFile.resources será el identificador del manifiesto del ensamblado.

Tenga en cuenta que cuando el editor de recursos agrega una imagen, establece Acción de generación en Ninguno, porque el archivo .resx hace referencia al archivo de imagen. En tiempo de generación, la imagen se extrae en el archivo .resources creado fuera del archivo .resx. A continuación, se puede tener acceso fácilmente a la imagen a través de la clase con establecimiento inflexible de tipos generada automáticamente para el archivo .resx. Por consiguiente, no debería cambiar esta configuración a Recurso incrustado, porque al hacerlo incluiría la imagen dos veces en el ensamblado.

Para obtener más información acera del acceso a los archivos de recursos (compilados a partir de archivos .resx) en tiempo de ejecución, consulte ResourceManager (Clase). Para obtener más información sobre cómo tener acceso a todos los demás archivos y recursos incrustados en tiempo de ejecución, consulte Assembly.GetManifestResourceStream (Método).

Propiedad CopyToOutputDirectory.

Esta propiedad especifica las condiciones en las que el archivo de código fuente seleccionada se copiará en el directorio de salida. Seleccione No copiar si el archivo nunca se va a copiar en el directorio de resultados. Seleccione Copiar siempre si el archivo siempre se copiará en el directorio de resultados. Seleccione Copiar si es posterior si el archivo sólo se copiará cuando sea más reciente que un archivo con el mismo nombre que esté presente en el directorio de resultados.

Nota:

En los proyectos para dispositivos inteligentes, la novedad de un archivo .dll o .exe se determina mediante la comparación de las versiones de Win32 de la


http://msdn.microsoft.com/es-es/library/system.resources.resourcemanager%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/system.reflection.assembly.getmanifestresourcestream%28v=vs.90%29.aspx


siguiente forma:

Si la versión del dispositivo es anterior a la del escritorio, se copia el archivo.

Si la versión del dispositivo es posterior a la del escritorio, no se copia el archivo.

Si las versiones son iguales, se realiza una comparación de la suma de comprobación. Si las sumas de comprobación son iguales, no se copia el archivo y si son diferentes, se copia el archivo.

La novedad de los archivos que no sean .dll ni .exe se basa únicamente en la suma de comprobación.

Nota:

Los archivos de datos se copiarán en una subcarpeta denominada Archivos de los Datos en el directorio de resultados.

Propiedad CustomTool.

Las herramientas personalizadas son componentes que se pueden utilizar para transformar archivos de un tipo a otro en tiempo de diseño. Por ejemplo, una herramienta personalizada puede ser un generador de código de conjunto de datos que lee un archivo de esquema XML (.xsd), y genera clases en un archivo de código que expone sus tablas y columnas mediante programación. En el producto se dispone de una lista predefinida de las herramientas personalizadas disponibles; esta propiedad permite ver la herramienta personalizada que se aplica a un archivo. En raras ocasiones, quizá deba cambiar el valor de esta propiedad. El valor de esta propiedad debe estar en blanco o ser una de las herramientas personalizadas integradas.

Para establecer o cambiar la herramienta personalizada, haga clic en la propiedad CustomTool en la ventana Propiedades y escriba el nombre de una herramienta personalizada.

Propiedad CustomToolNamespace.

Si ha asignado una herramienta personalizada al proyecto, la propiedad CustomToolNamespace permite especificar el espacio de nombres que desea asignar al código generado por la herramienta personalizada. Al especificar un valor para la propiedad CustomToolNamespace, el código generado por la herramienta se colocará en el espacio de nombres especificado. Si la propiedad está vacía, el código generado se coloca en el espacio de nombres predeterminado para la carpeta en la que se encuentra el archivo convertido. Para Visual Basic, se trata del espacio de nombres raíz del proyecto; para



Visual C#, corresponde al valor de la propiedad DefaultNamespace de la carpeta.

Plantillas de proyectos predeterminadas en Visual Studio:

Cuando se crea un nuevo proyecto, los iconos de los cuadros de diálogo Nuevo proyecto y Agregar proyecto representan los tipos de proyecto disponibles y sus plantillas. La plantilla de proyecto asociada con el icono de proyecto elegido determina el tipo de resultado y otras opciones disponibles para el proyecto.

La tabla siguiente muestra los tipos predeterminados de proyectos disponibles en Visual Studio.

Plantilla de proyecto Se utiliza para crear:

Plantilla de biblioteca de clases

Clases o componentes reutilizables que puedan compartirse con otros proyectos. Este tipo de proyecto se considera que no tiene ventanas y no contendrá una clase de formulario Windows Forms. Para obtener más información, vea Clases de componentes.

Plantilla de aplicación de consola

Aplicaciones de línea de comandos.

Plantilla de proyecto vacía

Proyecto vacío. La plantilla crea la estructura de archivos necesaria para almacenar la información de la aplicación; las referencias, archivos o componentes deben agregarse manualmente.

Plantilla de biblioteca de controles Web

Controles personalizados para utilizarlos en páginas de formularios Web Forms.

Plantilla de aplicaciones para Windows

Aplicaciones autónomas tradicionales para Windows o una interfaz rica para una aplicación Web distribuida. Para obtener más información, vea Crear aplicaciones para Windows.

Nota para Visual Basic:

Reemplaza a la plantilla de proyecto EXE estándar de Visual Basic 6.0.

Plantilla de biblioteca de controles de Windows

Controles personalizados para utilizarlos en formularios Windows Forms. Para obtener más información, vea Creación de controles para formularios Windows Forms.

Nota para Visual Basic:

Este tipo de proyecto es análogo al proyecto Control ActiveX de Visual Basic 6.0.

Plantilla de servicio de Windows

Aplicaciones de larga duración que no tienen una interfaz de usuario. Las aplicaciones de servicios de Windows (antes denominadas "servicios NT") pueden supervisar elementos tales como el rendimiento del sistema. Para obtener más información, vea Introducción a las aplicaciones de servicios de Windows.


http://msdn.microsoft.com/es-es/library/3e6w3tyx%28v=vs.90%29.aspx



http://msdn.microsoft.com/es-es/library/8zzftay8%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/k1s1x6ck%28v=vs.90%29.aspx



http://msdn.microsoft.com/es-es/library/sw2c06y2%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/sw2c06y2%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/f3a1bsb5%28v=vs.90%29.aspx



http://msdn.microsoft.com/es-es/library/69a80x00%28v=vs.90%29.aspx



http://msdn.microsoft.com/es-es/library/54xbah2z%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/kxczf775%28v=vs.90%29.aspx




http://msdn.microsoft.com/es-es/library/w29y3h59%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/w29y3h59%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/1xzez001%28v=vs.90%29.aspx



http://msdn.microsoft.com/es-es/library/d56de412%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/d56de412%28v=vs.90%29.aspx


Elaborar programa en modo consola.

Puede usar Visual C++ en el entorno de desarrollo integrado (IDE) de Visual Studio para crear programas en C++ estándar. Si siguimos los pasos de este tutorial, podemos crear un proyecto, agregar un nuevo archivo al proyecto, modificar el archivo para agregar código de C++ y, finalmente, compilar y ejecutar el programa con Visual Studio.

Puede escribir su propio programa de C++ o utilizar uno de los programas de ejemplo. El programa de ejemplo de este tutorial es una aplicación de consola. Esta aplicación usa el contenedor set de la Biblioteca de plantillas estándar (STL).

Visual C++ cumple la norma de 2003 C++ excepto en estos casos: búsquedas de nombres en dos fases, especificaciones de excepciones y exportaciones. Además, Visual C++ admite varias características de C++0x, como lambda, auto, static_assert, referencias rvalue y plantillas extern.

Nota Si se requiere cumplimiento normativo, use la opción del compilador /Za para deshabilitar las extensiones de Microsoft para la norma. Para obtener más información, vea /Za, /Ze (Deshabilitar extensiones de lenguaje).

Pasos para crear un proyecto por consola:

1. Para crear un nuevo proyecto, en el menú Archivo, elija Nuevo y haga clic en Proyecto.

2. En el panel de tipos de proyecto de Visual C++, haga clic en Win32 y, a continuación, en Aplicación de consola Win32.

3. Escriba un nombre para el proyecto.

De forma predeterminada, la solución que contiene el proyecto tiene el mismo nombre que el proyecto, pero puede escribir un nombre diferente. También puede escribir una ubicación diferente para el proyecto.

Haga clic en Aceptar para crear el proyecto.

4. En el Asistente para aplicaciones Win32, haga clic en Siguiente, seleccione Proyecto vacío y, a continuación, haga clic en Finalizar.

5. Si no aparece el Explorador de soluciones, en el menú Ver, haga clic en Explorador de soluciones.

6. Agregue un nuevo archivo de origen al proyecto como se indica a continuación.


http://msdn.microsoft.com/es-es/library/0k0w269d.aspx


En el Explorador de soluciones, haga clic con el botón secundario en la carpeta Archivos de origen, elija Agregar y, a continuación, seleccione Nuevo elemento.

En el nodo Código, haga clic en Archivo C++ (.cpp), escriba un nombre para el archivo y, a continuación, haga clic en Agregar.

El archivo .cpp aparece en la carpeta de archivos de origen del Explorador de soluciones y el archivo se abre en el editor de Visual Studio.

7. En el archivo del editor, escriba un programa de C++ válido que use la Biblioteca estándar de C++ o copie uno de los programas de ejemplo y péguelo en el archivo.

Por ejemplo, puede usar el programa set::find (Ejemplos de STL), que es uno de los ejemplos de Biblioteca de plantillas estándar incluidos en la Ayuda.

Si usa el programa de ejemplo, observe la directiva using namespace std;. Esta directiva permite al programa usar cout y endl sin requerir nombres completos (std::cout y std::endl).

8. Guarde el archivo.

9. En el menú Compilar, haga clic en Compilar solución. La Ventana de salida muestra información sobre el progreso de compilación; por ejemplo, la ubicación del registro de compilación y un mensaje que indica el estado de la misma.

10. En el menú Depurar, haga clic en Iniciar sin depurar.

Si usó el programa de ejemplo, aparece una ventana de comandos que indica si hay determinados enteros en el conjunto.

Ejemplo

Antes de seguir debes haber instalado Vistual Studio 2010 (en adelante VS2010) en tu sistema Windows. Si no lo ha hecho aún, consulta el documento Visual C++ Instalación en esta misma sección Herramientas de desarrollo del Campus Virtual. Sigue sus instrucciones para instalar VS2010 en su versión para C++.

VS2010 además de ofrecer un editor para crear los fuentes y archivos encabezados de una aplicación C++ integra a través de opciones de menú las herramientas necesarias para compilar y enlazar una aplicación C++. Adicionalmente, VS2010 permite utilizar, a través de la consola de comandos,


http://msdn.microsoft.com/es-es/library/ets82w6a.aspx


una gran parte de las herramientas que son invocadas automáticamente a través de las opciones de menú. Entre otras, es posible invocar al compilador y al enlazador.

Para poder ejecutar las órdenes de compilación de VS2010 necesitamos una consola (o ventana de terminal), que es una ventana de modo texto que permite dar instrucciones al sistema operativo (SO) ejecutando órdenes una por una.

El SO entiende una serie de órdenes por defecto (dir, cd, copy, move, ...), cada una con su sintaxis que hay que respetar. Y a medida que instalamos determinados programas se añaden órdenes que se pueden ejecutar en la consola. Por ejemplo, tras instalar MinGW podemos usar la orden g++ para compilar programa en C++, o en el caso de VS2010 podemos utilizar las herramientas de consola que vienen incluidas.

Por comodidad para el desarrollador, cuando se instala VS2010 se configura un acceso directo a una consola (o terminal) preconfigurada para poder utilizar directamente todas las herramientas en modo consola que vienen con el VS2010. Para abrir una consola usa la opción Símbolo del sistema para Visual Studio 2010 del grupo de programas Microsoft Visual Studio 2010 Express. Se abrirá una ventana similar a esta:

Como ves, es una ventana en modo texto. Lo único que se pueden mostrar son filas de caracteres. No hay gráficos.

En las consolas siempre hay un indicativo (prompt) al que le sigue un cursor de texto parpadeante que indica dónde se pondrá el siguiente carácter que se escriba (al principio, tras el indicativo, o tras el último carácter escrito).



En la ilustración, el indicativo es C:\Archivos de programa\Microsoft Visual Studio 10.0\VC> y el cursor tiene la forma de un guión bajo (o subrayado). El tu ventana lo verás parpadear.

El indicativo por defecto muestra la carpeta actual seguida del símbolo mayor que (>). El cursor está esperando que escribamos una orden.

Por ejemplo, escribe dir. Es la orden que te permite ver el contenido de la carpeta actual.

Una vez escrita una orden la ejecutamos pulsando la tecla Intro. Hazlo y verás aparecer un listado de las subcarpetas y archivos que hay en esa carpeta (C:\Archivos de programa\Microsoft Visual Studio 10.0\VC, en mi caso):

(Puedes alargar la ventana hacia abajo para ver más líneas.) El listado tiene cinco columnas: la fecha y la hora de creación o modificación, si se trata de una subcarpeta (<DIR>), el tamaño del archivo (en bytes) y el nombre del archivo o carpeta.

La subcarpeta .. es especial, ya que hace referencia a la carpeta madre (en este ejemplo, C:\Archivos de programa\Microsoft Visual Studio 10.0\).

Otra orden que necesitas conocer es la que te permite cambiar a otras carpetas. Es cd y debe llevar a continuación (separado por un espacio) el nombre de la (sub)carpeta a la que queremos ir. O .., para ir a la carpeta madre. Ejecuta cd .. y llegarás a la carpeta madre.

Lo sabrás porque el indicativo así lo dice:



Puedes observar también que al ir ejecutando órdenes y al salir las líneas que producen las órdenes se van desplazando las líneas anteriores hacia arriba y se dejan de ver. Si queremos volver a verlas podemos utilizar la barra de desplazamiento de la ventana.

Bueno, ya vas conociendo algunas órdenes del SO que utilizarás a menudo en las consolas. Usarás pocas más, ya que lo que nos interesa es compilar programas, lo que haremos siempre con la orden cl que VS2010 ha añadido al instalarse.

Con cd te puedes desplazar a la carpeta en que estén los archivos con el código C++ que deseas compilar. Y dir te servirá para ver los nombres de esos archivos. Pero los archivos los crearás y editarás más cómodamente con una aplicación Windows con todas sus facilidades. Y las operaciones de mantenimiento de los archivos, con el Explorador de Windows.

Antes de compilar nuestro primer programa C++ vamos a organizarnos un poco. Vamos a crear una carpeta en la que ir colocando los distintos programas que iremos desarrollando a lo largo del curso. Llamémosla FP.

La crearemos en la raíz del disco, para que nos cueste poco llegar a ella en la ventana de consola. Ejecuta en la consola la orden cd .. hasta que ya no produzca ningún cambio. (Por cierto, puedes volver a ejecutar órdenes anteriores usando las teclas de flecha arriba y abajo para ir recorriendo el historial de órdenes; para quitar la que haya basta con que pulses la tecla Esc.)

Estarás ahora en la carpeta raíz del disco. El indicativo sólo muestra la letra de la unidad de disco, dos puntos y una barra invertida (aparte del >):



Puedes crear las carpetas utilizando el Explorador de Windows, o ejecutar en la consola las instrucciones siguientes. Para crear la carpeta FP, ejecuta mkdir FP. mkdir es la orden que permite crear una subcarpeta. Cambia a esa nueva carpeta ejecutando cd FP.

Como vamos a desarrollar muchos programas a lo largo del curso, organicemos un poco más creando subcarpetas para las distintas unidades (y prácticas).

Asegúrate de que estás en la carpeta FP (mira el indicativo actual). Ejecuta mkdir Unidad02 (o mkdir Tema2, lo que prefieras). Y pasa esa nueva carpeta con cd Unidad02 (o cd Tema2).

Ya estás en la carpeta donde queremos compilar. ¿Compilar qué? Como acabamos de crear la carpeta, no hay nada en ella (ejecuta dir):



. Representa la propia carpeta actual y .. la carpeta madre. Esos dos elementos siempre están. Pero no hay nada más, ningún programa en C++. (Si quieres borrar el contenido de la consola usa la orden cls.)

Pongamos el programa Hola Mundo! para una primera prueba de compilación. Pulsa el siguiente vínculo que aparece a continuación. Te abrirá una nueva ficha (o ventana) con el texto del programa.

Programa Hola Mundo!

Usa los menús del navegador para guardar el documento abierto. Asegúrate de que se guarde como archivo de texto (*.txt) y que tenga el nombre hola.cpp. Una vez hecho, vuelve a la ventana de consola y ejecuta dir:

Ya debe aparecer el archivo hola.cpp. Si, por cualquier motivo, el archivo tuviera un nombre diferente, usa la orden ren (renombrar) para que tenga el deseado. Por ejemplo, si el archivo se llama hola_cpp.txt, ejecuta la orden ren hola_cpp.txt hola.cpp.

Ahora que ya tenemos un programa en la carpeta, podemos compilarlo para que se genere el correspondiente archivo ejecutable. Como ya sabemos, usaremos la orden cl. La sintaxis básica para compilar un programa es la siguiente:

cl /Feejecutable programa.cpp

Donde ejecutable es el nombre que queremos para el archivo ejecutable resultante (si todo va bien) y programa es el nombre del programa (siempre con extensión .cpp). En este caso, programa es hola y como archivo ejecutable


http://www.fdi.ucm.es/profesor/luis/fp/devtools/hola.cpp


podemos elegir hola.exe (si no ponemos extensión, añadirá .exe automáticamente). Así, en nuestro caso la orden será:

cl /Fehola.exe hola.cpp

Básicamente lo que le decimos a al compilador de VS2010 es que compile una serie de archivos de código (aquí sólo hay uno, pero podríamos poner varios .cpp, separados por un espacio). Además, podemos incluir opciones de compilación. Las opciones empiezan por un guión (/) y cada una tiene una o varias letras que la identifica. Por ejemplo /Fe es la opción de compilación que permite dar un nombre a la salida (output) de la compilación (la salida es el programa ejecutable). Hay muchas opciones de compilación, pero de momento nos basta con /Fe. Aprenderás alguna otra a lo largo del curso, pero si tienes curiosidad puedes consultar las opciones disponibles y una breve descripción de las mismas ejecutando cl /?.

Escribe y ejecuta la orden anterior en la consola:

Como vemos, se genera un aviso (warning) relacionado con el controlador de excepciones que en estos momentos no es importante.

Si cl no muestra ningún mensaje de error (mensajes marcados como Error), entonces es que no ha habido ningún error de compilación. Se habrá generado el ejecutable y se podrá ejecutar. Ejecuta dir y verás cómo ya tienes un archivo hola.exe.

Los archivos ejecutables se identifican como tales al tener la extensión .exe. Basta ejecutar su nombre (sin la extensión) para que pongan en marcha. Ejecuta hola:



¡Enhorabuena! Ya has conseguido compilar y ejecutar tu primer programa en C++.

Pero es importante que sepas qué ocurre cuando no todo va bien, cuando cometemos errores de programación. Para comprobar qué hace el compilador de VS2010 cuando encuentra errores, edita el programa (hola.cpp) y:

• Quita la directiva inicial (#include … using … std;) • Quita las comillas de cierre de la cadena. • Deletrea mal return (por ejemplo, retrun). • Quita un punto y coma. • Quita { o }. • Deletrea mal Mundo (por ejemplo, "Hola Mondo!").

Para cada caso, compila y vuelve a dejar el programa como estaba tras comprobar el efecto del cambio.

¿Qué ocurre en el primer caso, por ejemplo? Pues que no se entiende los que son los identificadores cout y endl:



Bastante lógico, al estar definidos esos identificadores en la biblioteca iostream. Aparecen dos errores de compilación que hay que solucionar (volviendo a añadir la cabecera en este caso).

Diseñar y programar un formulario. • Definir el diseño del formulario de elemento de trabajo.

Cuando diseña un formulario de elemento de trabajo, desea colocar los campos en el formulario para que admitan la entrada de datos y los procesos de flujo de trabajo que los miembros del equipo seguirán. Si simplemente está agregando algunos campos a un formulario existente, debe determinar en qué parte del formulario desea agregarlos. Si está agregando varios campos para que admitan una nueva colección de datos cuyo seguimiento se va a llevar a cabo, tal vez simplemente desee agregar una nueva pestaña para estos campos. Para minimizar la necesidad de desplazarse por el formulario, puede agrupar los campos en varias columnas al principio del formulario o en una pestaña.

Si está agregando un nuevo tipo de elemento de trabajo, tal vez desee copiar un tipo existente y modificarlo para mostrar los campos y el proceso de flujo de trabajo compatible con ese nuevo tipo.

Cuando defina el diseño, tenga en cuenta las siguientes sugerencias para obtener los mejores resultados:

Aquellos campos que los miembros necesiten actualizar o a los que tengan que hacer referencia con frecuencia sitúelos al comienzo del formulario.

Aquellos campos que los miembros del equipo tengan que actualizar o a los que tengan que hacer referencia de forma esporádica sitúelos en una pestaña. Por ejemplo, los controles que vinculan elementos de trabajo o adjuntan archivos normalmente se sitúan en pestañas independientes.

Agrupe los campos en columnas para maximizar la presentación de los campos de datos. Puede usar columnas en la parte superior del formulario o en una pestaña. También puede mostrar las pestañas en un formato con varias columnas.

Use uno o varios controles de vinculación en pestañas independientes o en la misma pestaña para restringir los tipos de vínculos que se pueden crear entre los campos de tipos de elemento de trabajo.

• Segmentar el formulario en áreas.

Puede usar los elementos de diseño para segmentar su formulario de elemento de trabajo en áreas diferentes, agrupar campos relacionados y asignar espacio



en el formulario según los requisitos de entrada de datos. En la tabla siguiente se describen los elementos que se usan para segmentar el formulario en diferentes áreas.

Elemento Descripción

FORM Contiene los elementos Layout que determinan la presentación de los campos y los controles del tipo de elemento de trabajo.

Layout

Contiene todos los elementos que determinan la presentación de los campos y los controles de un determinado destino. Puede especificar diseños diferentes para los distintos destinos, como Visual Studio o Team Web Access. Los elementos secundarios que puede especificar en un elemento Layout son, entre otros, los elementos Control, Group, TabGroup y Splitter.

Group

Agrupa los elementos secundarios del formulario. Un borde y una etiqueta opcional separan visualmente un grupo. Los grupos que se definen en una posición adyacente en la pila XML se dividen en vertical en el formulario mostrado. Puede especificar el elemento Column como un elemento secundario de un elemento Group.

Column

Mantiene todos los elementos secundarios en una columna vertical o divide un formulario verticalmente. Las columnas deben aparecer en un Group. Los elementos Group de Column pueden utilizarse para crear áreas anidadas. De forma predeterminada, las columnas dividen un Group uniformemente. Puede especificar un atributo de ancho opcional de tipo porcentual para asignar más espacio a una o varias columnas.

Los elementos secundarios que puede especificar en un elemento Column son, entre otros, los elementos Control, Group, TabGroup y Splitter.

Splitter Permite a los usuarios cambiar el tamaño del ancho asignado a dos columnas de un formulario.

Tab

Agrega pestañas diferentes a un formulario para admitir la presentación de campos y controles adicionales. Los elementos secundarios que puede especificar en un elemento Tab son, entre otros, los elementos Control, Group, TabGroup y Splitter.

TabGroup Contiene un grupo de elementos TAB. En general, puede agregar las pestañas en un único grupo de pestañas. Sin embargo, podría apilar dos o más grupos de pestañas en un formulario.

En la siguiente ilustración puede ver un formulario en cuya área superior se muestran ocho campos organizados en dos columnas. En la parte inferior se muestran dos conjuntos de tres pestañas organizados en un diseño de dos columnas.

Formulario personalizado con tres pestañas en un diseño de dos columnas



Parte superior del formulario.

El siguiente código define la parte superior del formulario. Puede incorporar tantas columnas como sea necesario. Como se muestra en este ejemplo, la primera columna, cuyo tamaño es un 70 por ciento del ancho del formulario, contiene dos grupos de campos. El diseño del segundo grupo de campos, que contiene los campos PU (Use Area Path) y Priority, se establece en dos columnas. La segunda columna abarca el 30 por ciento restante del ancho del formulario. Cuando se cambia el tamaño del formulario, las áreas que están asignadas a las columnas varían proporcionalmente.

<FORM> <Layout> <Group> <Column PercentWidth="70"> <Group> <Column PercentWidth="100"> <Control FieldName="System.Title" Type="FieldControl" Label="Title" LabelPosition="Left" /> <Control FieldName="System.AreaPath" Type="WorkItemClassificationControl" Label="Area Path" LabelPosition="Left" /> <Control FieldName="System.IterationPath" Type="WorkItemClassificationControl" Label="&Iteration Path:" LabelPosition="Left" /> <Group> <Column PercentWidth="50"> <Control FieldName="Microsoft.VSTS.Common.ProductUnit" Type="FieldControl" Label="PU (Use Area Path)" LabelPosition="Left" /> </Column> <Column PercentWidth="50">



<Control FieldName="Microsoft.VSTS.Common.Priority" Type="FieldControl" Label="Priority" LabelPosition="Left" /> </Column> </Group> </Column> </Group> </Column> <Column PercentWidth="30"> <Group Label="Status"> <Column PercentWidth="100"> <Control FieldName="System.Id" Type="FieldControl" Label="Id" LabelPosition="Left" /> <Control FieldName="System.State" Type="FieldControl" Label="State" LabelPosition="Left" /> <Control FieldName="System.AssignedTo" Type="FieldControl" Label="Assigned To" LabelPosition="Left" /> </Column> </Group> </Column> </Group> <Group Label=""> <Column PercentWidth="60"> . . . </Layout> </FORM>

• Trabajar con pestañas.

Puede usar pestañas para reunir un grupo de campos o para admitir uno o varios controles especiales, como los controles que vinculan elementos de trabajo, vinculan el historial de elementos de trabajo o adjuntan archivos. Algunas definiciones de tipos de elemento de trabajo de las plantillas de procesos de Microsoft Solutions Framework (MSF) usan diversas pestañas para controlar los tipos de vínculos que se pueden crear, en función del tipo de vínculo. Para obtener más información, vea Tipos y flujo de trabajo de elementos de trabajo de la plantilla de proceso para Agile o Tipos y flujo de trabajo de elementos de trabajo de la plantilla de proceso para CMMI.

Para obtener más información sobre el uso de controles especiales, vea los temas siguientes:

- Proporcionar texto de ayuda, hipervínculos o contenido web en un formulario de elemento de trabajo.

- Agregar el control de datos adjuntos. - Definir controles de vínculos para restringir las relaciones de los vínculos.


http://msdn.microsoft.com/es-es/library/dd997897.aspx


http://msdn.microsoft.com/es-es/library/ee332488.aspx

http://msdn.microsoft.com/es-es/library/ee332488.aspx

http://msdn.microsoft.com/es-es/library/ff731584.aspx





Si se usan los atributos que se describen en la tabla siguiente, puede etiquetar la pestaña y especificar el relleno y los márgenes que controlan el número de píxeles del interior y exterior del borde del control de pestaña.

Atributo Descripción Label Requerido. Texto que especifica el nombre de la ficha. Margin Opcional. Especifica la cantidad de espacio (en píxeles) que debe haber en torno a

la pestaña. Padding Opcional. Especifica, en píxeles, la cantidad de espacio que debe haber en torno al

borde interior y exterior de la pestaña.

Seis pestañas organizadas en un diseño en paralelo.

En el código siguiente se muestra la sintaxis que se utiliza para crear el diseño que se representa en la ilustración anterior.

<FORM> <Layout> . . . <TabGroup> <Tab Label="Planning"> <Group Label="Status" Padding="(0,0,0,3)"> <Column PercentWidth="50"> <Control FieldName="Microsoft.DevDiv.Importance" Type="FieldControl" Label="Importance" LabelPosition="Left" /> <Control FieldName="Microsoft.DevDiv.Commitment" Type="FieldControl" Label="Commitment / Confidence" LabelPosition="Left" /> . . . </Column> <Column PercentWidth="50" /> </Group> <Group> <Column PercentWidth="100"> <Control FieldName="Microsoft.DevDiv.Story" Type="HtmlFieldControl" Label="Story Board" LabelPosition="Top" /> </Column> </Group> <Group> <Column PercentWidth="100">



<Control FieldName="System.Description" Type="HtmlFieldControl" Label="Value Proposition Description" LabelPosition="Top" /> </Column> </Group> </Tab> <Tab Label="Marketing"> <Group> <Column PercentWidth="100"> <Control FieldName="Microsoft.DevDiv.MarketingOwner" Type="FieldControl" Label="Marketing Owner" LabelPosition="Top" /> <Control FieldName="Microsoft.DevDiv.MarketingDescription" Type="HtmlFieldControl" Label="Marketing Description" LabelPosition="Top" /> </Column> </Group> </Tab> <Tab Label="Relationships"> <Control Type="LinksControl" Label="Pillars" LabelPosition="Top" Name="Pillars"> . . . </Control> <Control Type="LinksControl" Label="Experiences - Feature Groups" LabelPosition="Top" Name="Experiences"> . . . </Control> <Control Type="LinksControl" Label="Flags / Associations" LabelPosition="Top" Name="Flags"> . . . </Control> </Tab> </TabGroup> </Column> <Column PercentWidth="40"> <TabGroup> <Tab Label="History"> <Control FieldName="System.History" Type="WorkItemLogControl" Label="Detailed Description and History" LabelPosition="Top" Dock="Fill" /> </Tab> <Tab Label="Links"> <Control Type="LinksControl" LabelPosition="Top" > . . . </Control> </Tab> <Tab Label="File Attachments"> <Control Type="AttachmentsControl" LabelPosition="Top" /> </Tab> </TabGroup> </Column> </Group>



</Layout> </FORM>

• Agrupar campos.

Puede usar el elemento Group para agrupar elementos visualmente, como el control GroupBox de Windows. Si se usan los atributos que se describen en la tabla siguiente, puede etiquetar cada grupo y especificar el relleno y los márgenes que controlan el número de píxeles del interior y exterior del borde del área de grupo. El elemento Group debe ir seguido siempre de un elemento Column, aunque el grupo tenga solo una columna.

Debe utilizar el elemento Group como contenedor de los campos de una columna y como contenedor de las columnas de un área segmentada del formulario. El elemento Column solo puede especificarse como elemento secundario de un elemento Group.

Puede controlar el espaciado y el tamaño del diseño general del formulario especificando los atributos que se describen en la tabla siguiente.

Grupo de campos organizados en una pestaña.

En el código siguiente se muestra la sintaxis que se utiliza para crear el grupo de campos que se muestra en la ilustración anterior. Para obtener más información acerca de cómo se especifican los campos utilizando el elemento Control, vea Controlar cómo se muestran los campos de elementos de trabajo.

Atributo Descripción Label Opcional. Texto que especifica el nombre del grupo. Margin Opcional. Especifica la cantidad de espacio (en píxeles) que debe haber alrededor

del grupo y entre el control y sus elementos colindantes. Se puede variar la cantidad de espacio en cada lado.

Padding Opcional. Especifica la cantidad de espacio (en píxeles) que debe haber alrededor del borde exterior del grupo. Se puede variar la cantidad de espacio en cada lado.


http://msdn.microsoft.com/es-es/library/ms243845.aspx


<TabGroup> <Tab Label="Planning"> <Group Label="Status" Padding="(0,0,0,3)"> <Column PercentWidth="5100"> <Control FieldName="Microsoft.DevDiv.Importance" Type="FieldControl" Label="Importance" LabelPosition="Left" /> <Control FieldName="Microsoft.DevDiv.Commitment" Type="FieldControl" Label="Commitment / Confidence" LabelPosition="Left" /> <Control FieldName="Microsoft.DevDiv.VisionDoc" Type="FieldControl" Label="Vision Doc" LabelPosition="Left" /> <Control FieldName="Microsoft.DeveloperDivision.Features.EstimatedCost" Type="FieldControl" Label="Estimated Cost" LabelPosition="Left" /> <Control FieldName="Microsoft.DevDiv.BusinessUnit" Type="FieldControl" Label="BU (Use Area Path)" LabelPosition="Left" /> <Control FieldName="Microsoft.DevDiv.Website" Type="FieldControl" Label="Website" LabelPosition="Left" /> </Column> </Group> . . . </Tab> </TabGroup>

• Trabajar con columnas.

Puede diseñar un área en un formulario que tenga dos o más columnas. Puede especificar un ancho de columna fijo o porcentual, en relación con el ancho del elemento que lo contiene usando los atributos FixedWidth o PercentWidth, respectivamente. Estos dos atributos Column son mutuamente excluyentes. Para permitir a un usuario cambiar el tamaño de la columna, puede especificar un control Splitter, tal y como se describe en Usar un divisor para admitir tamaños de columna variables.

Diseño de tres columnas:

El siguiente código genera el diseño de campos en tres columnas mostrado anteriormente. Cuando organice grupos de campos en columnas, utilice el


http://msdn.microsoft.com/es-es/library/ms194952.aspx%23UsingSplitter

http://msdn.microsoft.com/es-es/library/ms194952.aspx%23UsingSplitter


elemento Group para que incluya cada columna de campos. Si lo desea, también puede etiquetar los grupos de campos.

<FORM> <Layout> <Group> <Column PercentWidth="36"> <Group> <Control FieldName="System.Title" Type="FieldControl" Label="Title" LabelPosition="Left" /> <Control FieldName="System.AreaPath" Type="WorkItemClassificationControl" Label="Area" LabelPosition="Left" /> <Control FieldName="Microsoft.VSTS.Common.ProductUnit" Type="FieldControl" Label="Product Unit" LabelPosition="Left" /> <Control FieldName="Microsoft.DevDiv.BusinessUnit" Type="FieldControl" Label="Business Unit" LabelPosition="Left" /> </Group> </Column> <Column PercentWidth="33"> <Group> <Control FieldName="Microsoft.DevDiv.SubTitle" Type="FieldControl" Label="Sub Title" LabelPosition="Left" /> <Control FieldName="System.IterationPath" Type="WorkItemClassificationControl" Label="Iteration" LabelPosition="Left" /> <Control FieldName="Microsoft.DevDiv.Other" Type="FieldControl" Label="Other" LabelPosition="Left" /> </Group> </Column> <Column PercentWidth="31"> <Group> <Control FieldName="Microsoft.DevDiv.Type" Type="FieldControl" Label="Type" LabelPosition="Left" /> <Control FieldName="System.AssignedTo" Type="FieldControl" Label="Assigned To" LabelPosition="Left" /> <Control FieldName="System.State" Type="FieldControl" Label="State" LabelPosition="Left" /> </Group> </Column> </Group> . . . </Layout> </FORM>



• Usar un divisor para admitir tamaños de columna variables.

Puede usar el elemento Splitter si desea que el visor del formulario pueda cambiar el tamaño de las columnas dinámicamente. El divisor aparece como una línea de puntos en el formulario, tal y como se muestra en la siguiente ilustración. No puede especificar ningún elemento secundario en el elemento Splitter.

iseño de dos columnas con un divisor:

Un elemento Group que contiene elementos Column y Splitter debe especificar exactamente tres elementos Column en la secuencia siguiente:

1. Un elemento Column a la izquierda del divisor. 2. Un elemento Column que contiene únicamente el elemento Splitter. 3. Un elemento Column a la derecha del divisor.

Vea el ejemplo siguiente para obtener más información.

<Group>

<Column PercentWidth="50">

<Group Label="First Group Left ">


<Control FieldName="Microsoft.VSTS.Common.Priority" Type="FieldControl" Name="Pri2" Label="Priority:" />

<Control FieldName="Microsoft.VSTS.Common.Rank" Type="FieldControl" Label="Stack Rank:" />

<Control FieldName="Microsoft.VSTS.Scheduling.BaselineWork" Type="FieldControl" Label="Original Estimate:" />

<Control FieldName="Microsoft.VSTS.Scheduling.RemainingWork" Type="FieldControl" Label="Remaining:" />



</Column>

<Column>

<Splitter>

</Column>


<Group Label="Second Group Right">

<Control Type="DateTimeControl" FieldName="ABC_Company.Project.Manual.ChangeDate" Label="Change Date" Format="Short" LabelPosition="Right" />

<Control Type="DateTimeControl" FieldName="ABC_Company.Project.Manual.EstimateStartDate" Label="Estimated Start Date" Format="Short" LabelPosition="Right" />

<Control Type="DateTimeControl" FieldName="ABC_Company.Project.Manual.ActualStartDate" Label="Actual Start Date" Format="Short" LabelPosition="Right" />

<Control Type="DateTimeControl" FieldName="ABC_Company.Project.Manual.FinishDate" Label="Finish Date" Format="Short" LabelPosition="Right" />

</Group>

</Column>

</Group>

• Controlar el tamaño del formulario y sus elementos.

Puede especificar el tamaño horizontal y vertical mínimo de cada diseño de formulario utilizando el atributo MinimumSize. Sin embargo, el formulario cambia de tamaño en función de las dimensiones combinadas cuando el tamaño horizontal y el tamaño vertical combinados de los controles de campo y los diseños definidos en cada formulario son mayores que las dimensiones mínimas especificadas. Además, el tamaño vertical de todas las pestañas se ajusta a la dimensión necesaria para establecer el tamaño de la pestaña con el diseño vertical máximo. El tamaño del último control de campo de cada pestaña se puede modificar como corresponda para rellenar la dimensión vertical.



Las barras de desplazamiento aparecen cuando el contenedor que está mostrando el diseño del formulario es menor que el tamaño mínimo horizontal o vertical del formulario. En este caso, podría producirse un problema de doble desplazamiento. Con el doble desplazamiento, los usuarios pueden tener que desplazar tanto el propio formulario como el control de campo para localizar la información que desean ver. Para evitar el problema de doble desplazamiento, quizás desee situar controles de campo, como campos HTML y campos de historial, que estén sujetos al desplazamiento de su propia pestaña.

• Controlar el tamaño del diseño.

Puede controlar el espaciado y el tamaño del diseño general del formulario especificando los atributos que se describen en la tabla siguiente.

Atributo Descripción Ejemplo de un valor de modelo

MinimumSize

Opcional. Cadena con el formato (Ancho, Alto). Este valor especifica el tamaño mínimo para el propio formulario. Cuando el contenedor en el que se muestra el diseño del formulario es menor que este tamaño, aparecen barras de desplazamiento horizontal y vertical. Cuando el tamaño combinado de los controles de campo del formulario de diseño es mayor que el tamaño definido por el atributo MinimumSize, se omite el atributo.

(100,100)

Margin

Opcional. Cadena con el formato (Izquierda, Superior, Derecha, Inferior) que especifica, en píxeles, la cantidad de espacio que debe haber alrededor del diseño. Se puede variar la cantidad de espacio en cada lado.

(2,0,2,0)

Padding

Opcional. Cadena con el formato ((Izquierda, Superior, Derecha, Inferior) que especifica, en píxeles, la cantidad de espacio que debe haber entre el borde exterior del diseño y el borde interior. Se puede variar la cantidad de espacio en cada lado.

(2,0,2,0)

ControlSpacing Opcional. Especifica el espaciado vertical entre los controles del formulario. Integer. N/D

• Controlar el tamaño de los elementos del formulario.

Puede usar el atributo MinimumSize del elemento Control para especificar el tamaño y el alto mínimos que cada elemento del formulario debe ocupar. Si no tiene espacio vertical suficiente, aparecerá una barra de desplazamiento para mantener el tamaño mínimo. Sin este atributo, los controles se dibujan con sus tamaños predeterminados, a menos que haya controles en otras pestañas que ocupen más espacio y que aumenten el tamaño de la pestaña. Puede utilizar otros atributos, como Dock, Margin y Padding, para alinear o ajustar el control y



definir el tamaño del borde que rodea al control. Para obtener más información, vea los temas siguientes:

• Especificar diseños diferentes para los distintos destinos.

Puede especificar diseños distintos para los diferentes destinos utilizando el atributo Target del elemento Layout. Si el destino es Visual Studio o Team Explorer Everywhere, puede especificar WinForms, y si el destino es Team Web Access, puede especificar Web.

<FORM> <Layout Target="WinForms" > . . . </Layout> <Layout Target="Web" > . . . </Layout > </FORM>

1. Ingrese por consola un numero, calcule y visualice: a) El cuadrado del número ingresado. b) La tercera parte del número ingresado.

El cubo del número ingresado

2. Ingrese por consola un numero de 3 cifras, calcule y visualice: a) La resta de sus cifras b) Promedio de las cifras restando la pimera cifra




III. PROGRAMAR ESTRUCTURAS CONDICIONALES. En esta tarea trataremos las siguientes operaciones:

Trabajar con constantes y variables. Identificar los tipos de datos que existen en visual net. Analizar la importancia de una estructura condicional.





Trabajar con constantes y variables. Identificar los tipos de datos que existen en visual net. Analizar la importancia de una estructura condicional.

03



3.1. TRABAJAR CON CONSTANTES Y VARIABLES.

• Variable.

Una variable representa un valor numérico o de cadena o un objeto de una clase. El valor que la variable almacena puede cambiar, pero el nombre sigue siendo el mismo. Una variable es un tipo de campo. El código siguiente es un ejemplo sencillo de cómo declarar una variable de entero, asignarle un valor y, a continuación, asignarle un nuevo valor.

C#

int x = 1; // x holds the value 1 x = 2; // now x holds the value 2

En C#, las variables se declaran con un tipo de datos y una etiqueta concretos. Si hasta ahora sólo ha utilizado lenguajes con tipos definidos de forma imprecisa como JScript, estará acostumbrado a emplear el mismo tipo "var" para todas las variables, pero en C# tiene que especificar si la variable es de tipo int, float, byte, short u otro cualquiera entre más de 20 tipos de datos diferentes. El tipo especifica, entre otras cosas, la cantidad de memoria exacta que se debe asignar para almacenar el valor cuando la aplicación se ejecuta. El lenguaje C# fuerza ciertas reglas al convertir una variable de un tipo en otro. Para obtener más información, vea Tipos de datos integrados (Visual C# Express).

C#

int answer = 42; string greeting = "Hello, World!"; double bigNumber = 1e100; System.Console.WriteLine("{0} {1} {2}", answer, greeting, bigNumber);

• Constantes.

Una constante es otro tipo de campo. Contiene un valor que se asigna cuando se compila el programa y nunca cambia después. Las constantes se declaran con la palabra clave const; son útiles para que el código sea más legible. C# const int speedLimit = 55; const double pi = 3.14159265358979323846264338327950; Una variable readonly es como una constante pero su valor se asigna al iniciar el programa. Esto le permite establecer el valor basándose en alguna otra


http://msdn.microsoft.com/es-es/library/cs7y5x0x%28v=vs.90%29.aspx


http://msdn.microsoft.com/es-es/library/e6w8fe1b%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/acdd6hb7%28v=vs.90%29.aspx


condición que no conoce hasta que se ejecuta el programa. Pero después de esa primera asignación, el valor no puede cambiar de nuevo mientras el programa se está ejecutando.

3.2. IDENTIFICAR LOS TIPOS DE DATOS QUE EXISTEN EN VISUAL NET.

C# es un lenguaje con establecimiento inflexible de tipos. Antes de que un valor se pueda almacenar en una variable, se debe especificar el tipo de la variable, como en los ejemplos siguientes: int a = 1; string s = "Hello"; XmlDocument tempDocument = new XmlDocument(); Observe que el tipo se debe especificar igualmente para los tipos simples integrados como int y para los tipos complejos o personalizados como XmlDocument. C# es compatible con los siguientes tipos de datos integrados: Tipo de datos Intervalo

byte 0 .. 255 sbyte -128 .. 127 short -32,768 .. 32,767

ushort 0 .. 65,535 int -2,147,483,648 .. 2,147,483,647

uint 0 .. 4,294,967,295 long -9,223,372,036,854,775,808 .. 9,223,372,036,854,775,807

ulong 0 .. 18,446,744,073,709,551,615 float -3.402823e38 .. 3.402823e38

double -1.79769313486232e308 .. 1.79769313486232e308 decimal -79228162514264337593543950335 .. 79228162514264337593543950335

char Un carácter Unicode. string Una cadena de caracteres Unicode. bool True o False.

object Un objeto. Estos nombres de tipo de datos son los alias para los tipos predefinidos en el espacio de nombres System. Estos se muestran en la sección Tabla de tipos integrados (Referencia de C#). Todos estos tipos, salvo el objeto y la cadena, son tipos de valores. Para obtener más información, vea Tipos de referencia y de valor (Visual C# Express).

• Utilizar los tipos de datos integrados.

Los tipos de datos integrados se utilizan dentro de un programa C# de diferentes maneras.


http://msdn.microsoft.com/es-es/library/5kzh1b5w%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/system.xml.xmldocument%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/system%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/ya5y69ds%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/ya5y69ds%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/4d43ts61%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/4d43ts61%28v=vs.90%29.aspx


Como variables: C# int answer = 42; string greeting = "Hello, World!"; Como constantes: C# const int speedLimit = 55; const double pi = 3.14159265358979323846264338327950; Como valores devueltos y parámetros: C# long CalculateSum(int a, int b) { long result = a + b; return result; } Para definir sus propios tipos de datos, utilice Clases (Visual C# Express), Enumeraciones (Visual C# Express) o Estructuras (Visual C# Express).

• Convertir tipos de datos.

Los tipos de datos se pueden convertir implícitamente, en cuyo caso el compilador hace automáticamente la conversión, o explícitamente utilizando un operador de conversión explícita, donde el programador fuerza la conversión y asume el riesgo de perder información. Por ejemplo: C# int i = 0; double d = 0; i = 10; d = i; // An implicit conversion d = 3.5; i = (int) d; // An explicit conversion, or "cast"

3.3. ANALIZAR LA IMPORTANCIA DE UNA ESTRUCTURA CONDICIONAL.


http://msdn.microsoft.com/es-es/library/ey4ke239%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/4s1w24dx%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/89892kc7%28v=vs.90%29.aspx


Los métodos condicionales permiten a los programadores crear métodos cuyas llamadas se pueden colocar en el código y, después, incluirlos u omitirlos durante la compilación según un símbolo de preprocesamiento.

Suponga que desea habilitar cierto código de aserción en las versiones generadas para depuración, y omitirlo en las versiones comerciales. En C++, existe más de un modo de implementar esta funcionalidad en el código, por ejemplo:

Mediante #ifdef se definen ambas versiones, de depuración y lanzamiento, de una macro. La versión de depuración llama al código de seguimiento, mientras que la versión de lanzamiento no hace nada. Como C# no admite macros, este método no funciona.

Tener dos implementaciones del código al que se llama. Es decir, en la versión de depuración, tener funcionalidad completa y, en la versión comercial, código auxiliar vacío para los métodos. Los usuarios eligen cuál desean incluir cuando vinculan el proyecto. El problema de este enfoque es que las versiones comerciales contienen llamadas a métodos vacíos, y esta configuración resulta más compleja.

Los métodos condicionales de C# proporcionan una solución simple a este problema, similar al primer enfoque indicado anteriormente. Existen dos mecanismos básicos para hacerlo:

Definir, mediante #define, el identificador de preprocesamiento directamente en el código fuente. Vea un ejemplo de este enfoque en Conditional.

Definir el identificador de preprocesamiento en la línea de comandos de C# mediante la opción /define (/d). Este método se utiliza en el siguiente ejemplo.

Los métodos condicionales se utilizan en la plataforma .NET Framework. El espacio de nombres System.Diagnostics contiene una serie de clases que permiten el seguimiento y la depuración de aplicaciones. Utilice las clases System.Diagnostics.Trace y System.Diagnostics.Debug para agregar sofisticadas capacidades de seguimiento y depuración a una aplicación (esta funcionalidad se puede obtener de las versiones comerciales mediante el uso de métodos condicionales).

El ejemplo siguiente muestra cómo implementar un mecanismo de seguimiento muy simple mediante métodos condicionales. System.Diagnostics.Trace proporciona mecanismos de seguimiento mucho más sofisticados, pero utiliza el mecanismo fundamental que se indica a continuación para ofrecer esta funcionalidad.


http://msdn.microsoft.com/es-es/library/4xssyw96%28v=vs.71%29.aspx


Ejemplo

Este ejemplo consta de dos archivos de código fuente: el primero es la biblioteca que proporciona un mecanismo de seguimiento, mientras que el segundo es el programa cliente que utiliza esta biblioteca.

Archivo #1: crear métodos condicionales

El código siguiente muestra una simple biblioteca que proporciona un mecanismo de seguimiento que muestra mensajes en la consola del sistema. Los clientes pueden incrustar llamadas de seguimiento en el código y, después, ser capaces de controlar cuándo se utilizan, mediante la definición de símbolos en su propia fase de compilación.

// CondMethod.cs // compile with: /target:library /d:DEBUG using System; using System.Diagnostics; namespace TraceFunctions { public class Trace { [Conditional("DEBUG")] public static void Message(string traceMessage) { Console.WriteLine("[TRACE] - " + traceMessage); } } }

Descripción del código

La siguiente línea:

[Conditional("DEBUG")]

marca el método Message como condicional (por medio del atributo Conditional). El atributo Conditional recibe un parámetro: el identificador de preprocesamiento que controla si se incluye la llamada al método cuando se compilan los clientes. Si el identificador de preprocesamiento está definido, se realiza una llamada al método; en caso contrario, la llamada no se inserta en el código del cliente.

Existen algunas restricciones sobre qué métodos se pueden marcar como condicionales; para obtener más información, vea 17.4.2 El atributo Conditional en Especificación del lenguaje C#.


http://msdn.microsoft.com/es-es/library/aa664622%28v=vs.71%29.aspx


Archivo #2: utilizar el método condicional

El siguiente programa cliente utiliza la clase Trace, definida en el archivo #1, para realizar un seguimiento sencillo.

// TraceTest.cs // compile with: /reference:CondMethod.dll // arguments: A B C using System; using TraceFunctions; public class TraceClient { public static void Main(string[] args) { Trace.Message("Main Starting"); if (args.Length == 0) { Console.WriteLine("No arguments have been passed"); } else { for( int i=0; i < args.Length; i++) { Console.WriteLine("Arg[{0}] is [{1}]",i,args[i]); } } Trace.Message("Main Ending"); } }

Descripción del código

El código condicional se incluye en el código del cliente dependiendo de si el identificador de preprocesamiento está definido cuando se compila el código del cliente.

Compilar con el código del cliente y el indicador /d:DEBUG significa que el compilador inserta la llamada en el método Trace. Si el símbolo no está definido, la llamada no se realiza.

Ejecución de ejemplo



El comando:

tracetest A B C

produce el siguiente resultado:

[TRACE] - Main Starting Arg[0] is [A] Arg[1] is [B] Arg[2] is [C] [TRACE] - Main Ending

El comando:

tracetest

produce el siguiente resultado:

[TRACE] - Main Starting No arguments have been passed [TRACE] - Main Ending

• Estructuras condicionales simples y compuestas.

La estructura do while es otra estructura repetitiva, la cual ejecuta al menos una vez su bloque repetitivo, a diferencia del while o del for que podían no ejecutar el bloque.

Esta estructura repetitiva se utiliza cuando conocemos de antemano que por lo menos una vez se ejecutará el bloque repetitivo.

La condición de la estructura está abajo del bloque a repetir, a diferencia del while o del for que está en la parte superior.

Representación gráfica:



El bloque de operaciones se repite MIENTRAS que la condición sea Verdadera.

Si la condición retorna Falso el ciclo se detiene. En C#, todos los ciclos repiten por verdadero y cortan por falso.

Es importante analizar y ver que las operaciones se ejecutan como mínimo una vez.

Problema 1:

Escribir un programa que solicite la carga de un número entre 0 y 999, y nos muestre un mensaje de cuántos dígitos tiene el mismo. Finalizar el programa cuando se cargue el valor 0.

Diagrama de flujo:



No hay que confundir los rombos de las estructuras condicionales con los de las estructuras repetitivas do while.

En este problema por lo menos se carga un valor. Si se carga un valor mayor o igual a 100 se trata de un número de tres cifras, si es mayor o igual a 10 se trata de un valor de dos dígitos, en caso contrario se trata de un valor de un dígito.

Este bloque se repite hasta que se ingresa en la variable valor el número 0 con lo que la condición de la estructura do while retorna falso y sale del bloque repetitivo finalizando el programa.

Ejemplo 1:

Un hombre desea saber cuanto dinero se genera por concepto de intereses sobre la cantidad que tiene en inversión en el banco.

El decidirá reinvertir los intereses siempre y cuando estos excedan a S/.7000, y en ese caso desea saber cuanto dinero tendrá finalmente en su cuenta.

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace ejercicio01 { class Hombre { private string nombre; private float dinero; public void Inicio() { Console.WriteLine("---------BANCO COMOPROGRAMAR.ORG--------"); Console.WriteLine("-----------------------------"); Console.WriteLine("INGRESE SU NOMBRE: "); nombre = Console.ReadLine(); Console.WriteLine("INGRESE SU MONTO DINERO; "); dinero = float.Parse(Console.ReadLine()); Console.Clear(); }



public void Imprimir() { Console.WriteLine("---------BANCO COMOPROGRAMAR.ORG--------"); Console.WriteLine("-----------------------------"); Console.WriteLine("NOMBRE: " + nombre); if (dinero > 7000) { Console.WriteLine("USTED NO PUEDE EXCEDER EL MONTO DE S/ 7000"); } else { Console.WriteLine("INVERSION: " + dinero); } Console.ReadLine(); } static void Main(string[] args) { Hombre per = new Hombre(); per.Inicio(); per.Imprimir(); } } }

Ejemplo 2:

En un almacén se hace un 20% de descuento a los clientes cuya compra supere los S/.1000 ¿ Cual será la cantidad que pagara una persona por su compra?

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace ejercicios02 {



class Cliente { private float descuento; private float precio; public void Inicio() { Console.WriteLine("INGRESE PRECIO: "); precio = float.Parse(Console.ReadLine()); Console.Clear(); } public void Descuento() { if (precio > 1000) { float res = (precio * 20) / 100; descuento = precio - res; Console.WriteLine("--------TIENDA KEDINN -------"); Console.WriteLine("DESCUENTO DEL 20% POR SUPERAR S/1000"); Console.WriteLine("PRECIO ES: " + descuento); Console.ReadLine(); } else { Console.WriteLine("--------TIENDA KEDINN -------"); Console.WriteLine("PRECIO ES: " + precio); Console.ReadLine(); } Console.ReadKey(); } static void Main(string[] args) { Console.WriteLine("--------TIENDA KEDINN -------"); Cliente clie = new Cliente(); clie.Inicio(); clie.Descuento(); } } }



Ejemplo 3:

Un obrero necesita calcular su salario semanal, el cual se obtiene de la siguiente manera: - Si trabaja 40 horas o menos se le paga S/.16 por hora - Si trabaja mas de 40 horas se le paga S/.16 por cada una de las primeras 40 horas y S/.20 por cada hora extra.

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace ejercicio3 { class Camisas { int camisas; float precio; public void Ingresar() { Console.WriteLine("INGRESE NUMERO DE CAMISAS"); camisas = int.Parse(Console.ReadLine()); Console.WriteLine("INGRESE PRECIO DE LAS CAMISAS"); precio = float.Parse(Console.ReadLine()); } public void Trabajo() { if (camisas >= 3) { float a = (precio * 20) / 100; float b = precio - a; Console.WriteLine("DESCUENTO 20% PRECIO ES: "+ b); } else { float a = (precio * 01) / 100; float b = precio - a; Console.WriteLine("DESCUENTO 20% PRECIO ES: " + b); } Console.ReadKey(); }



static void Main(string[] args) { Camisas sem = new Camisas(); sem.Ingresar(); sem.Trabajo(); } } }

Ejemplo 4:

Hacer un algoritmo que calcule el total a pagar por la compra de camisas.

Si se compran tres camisas o mas se aplica un descuento del 20% sobre el total de la compra y si son menos de tres camisas un descuento del 10%

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace ejercicio3 { class Camisas { float precio; public void Ingresar() { Console.WriteLine("-----EMPRESA FAEMAS-----"); Console.WriteLine("INGRESE PRECIO DE LAS CAMISAS"); precio = float.Parse(Console.ReadLine()); } public void Trabajo() { Console.WriteLine("-----EMPRESA FAEMAS-----"); if (precio >= 500000) {



Console.WriteLine("la empresa tendrá la capacidad de invertir de su propio dinero un 55% del monto de la compra, pedir prestado al banco un 30% y el resto lo pagara solicitando un crédito al fabricante "); } else { Console.WriteLine("la empresa tendrá capacidad de invertir de su propio dinero un 70% y el restante 30% lo pagará solicitando crédito al fabricante. " ); } Console.ReadKey(); } static void Main(string[] args) { Camisas sem = new Camisas(); sem.Ingresar(); sem.Trabajo(); } } }




Trabajar con constantes y variables. • Identificadores Dan nombre a variables, constantes y métodos. Constan de caracteres alfanuméricos y _ C# es Sensible a mayúsculas y minúsculas. Han de comenzar con letra o _ No pueden ser una palabra reservada… Abstract, as, base, bool, break, byte, case, catch, char, checked, class, const, continue, decimal,default, delegate, do, doublé, else, enum, event, explicit, extern, falce, finally, fixed, float, for, foreach, goto, if, implicit, in, int, interface, internal, lock, is, long, namespace, new, null, object, operator, out, override, params, private, protected, public, readonly, ref, return, sbyte, sealed, short, sizeof, stackaalloc, static, string, struct, switch, this, throw, true, try, typeof, uint, ulong, unchecked, unsafe, ushort, using, virtual, void, while. ...si no se usa el carácter ‘@’ como prefijo: Object @this; //@ previene el conflicto con "this" • Constantes

Las clases y las estructuras pueden declarar las constantes como miembros. Las constantes son valores que se conocen en tiempo de compilación y no cambian. (Para crear un valor constante que se inicializa en el tiempo de ejecución, utilice la palabra clave readonly.) Las constantes se declaran como campo utilizando la palabra clave const antes del tipo del campo. Las constantes se deben inicializar tal como se declaran. Por ejemplo:

C#

class Calendar1 { public const int months = 12; }

En este ejemplo, la constante months siempre será 12 y no se puede cambiar, ni siquiera puede hacerlo la propia clase. Las constantes tienen que ser de un tipo integral (sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double, decimal, bool o string), una enumeración o una referencia a null.





Se pueden declarar varias constantes del mismo tipo al mismo tiempo, por ejemplo:

C#

class Calendar2 { const int months = 12, weeks = 52, days = 365; }

La expresión utilizada para inicializar una constante puede hacer referencia a otra constante siempre que no cree una referencia circular. Por ejemplo:

C#

class Calendar3 { const int months = 12; const int weeks = 52; const int days = 365; const double daysPerWeek = days / weeks; const double daysPerMonth = days / months; }

Las constantes se pueden marcar como public, private, protected, internal o protectedinternal. Estos modificadores de acceso definen cómo los usuarios de la clase pueden tener acceso a la constante. Para obtener más información, vea Modificadores de acceso (Guía de programación de C#).

Es posible tener acceso a las constantes como si fueran campos estáticos, aunque no pueden utilizar la palabra clave static. Las expresiones que no están contenidas dentro de la clase que define la constante deben usar el nombre de la clase, un punto y el nombre de la constante para tener acceso a la constante. Por ejemplo:

C#

int birthstones = Calendar.months;

C#

int x = 1; // x holds the value 1 x = 2; // now x holds the value 2


http://msdn.microsoft.com/es-es/library/yzh058ae%28v=vs.80%29.aspx

http://msdn.microsoft.com/es-es/library/st6sy9xe%28v=vs.80%29.aspx

http://msdn.microsoft.com/es-es/library/bcd5672a%28v=vs.80%29.aspx

http://msdn.microsoft.com/es-es/library/7c5ka91b%28v=vs.80%29.aspx


http://msdn.microsoft.com/es-es/library/98f28cdx%28v=vs.80%29.aspx


El modificador const permite definir variables constantes: Una constante no cambia nunca su valor. Son implícitamente static.

Class Class1 { private const int min = 1; private const int max = 100; public const int rango = max – min; … static void Main() { Console.WriteLine(“{0}-{1}-{2}”, Class1.max,Class1.min,Class1.rango); // o también : Console.WriteLine(“{0}-{1}-{2}”,max, min, rango); } } • Variable.

- Una variable representa la localización en memoria donde una instancia de un tipo es guardada.

- Declaración: <tipodedato> <identificador>; - Recordar la distinción entre tipos de valor y tipos de referencia

i. Tipos de valor son tipos simples como ‘int’, ‘long’ y ‘char’ ii. Los objetos, strings y arrays son ejemplos de tipos de referencia

- Los tipos de valor se derivan de System.ValueType. - Comparación entre variables de tipo valor y variables tipo referencia:

I. Variables de tipo valor: Contienen sus datos directamente. Cada una tiene su propia copia de datos. Las operaciones sobre una no afectan a otra.

II. Variables de tipo referencia: Almacenan referencias a sus datos (conocidos como objetos). Dos variables de referencia pueden apuntar al mismo objeto. Las operaciones sobre una pueden afectar a otra.

Una variable representa un valor numérico o de cadena o un objeto de una clase. El valor que la variable almacena puede cambiar, pero el nombre sigue siendo el mismo. Una variable es un tipo de campo. El código siguiente es un ejemplo sencillo de cómo declarar una variable de entero, asignarle un valor y, a continuación, asignarle un nuevo valor.



• Inicialización de variables en la declaración: bool bln = true; byte byt1 = 22; char ch1=‘x’, ch2=‘\u0061’; // Unicode para ‘a’ decimal dec1 = 1.23M; double dbl1=1.23, dbl2=1.23D; short sh = 22; int i = 22; long lng1=22, lng2=22L; // ‘L’ long sbyte sb=22; float f=1.23F; ushort us1=22; uint ui1=22, ui2=22U; // ‘U’ unsigned

ulong ul1=22, ul2=22U, ul3=22L, ul4=2UL;

Los valores de referencia son creados con la palabra reservada new: object o = new System.Object(); Una variable String se puede inicializar directamente: string s = "Hola"; C# soporta secuencias de escape como en C: string s1 = "Hola\n"; // salto de línea string s2 = "Hola\tque\ttal"; // tabulador Como las sentencias de escape comienzan con ‘\’, para escribir este carácter hay que doblarlo, o usar ‘@’: string s3 = "c:\\WINNT";

string s4 = @"C:\WINNT";

• Àmbito y Visibilidad:

Ámbito: lugar donde se declara una variable. Determina su accesibilidad.

La visibilidad de una variable fuera de su ámbito se puede modificar anteponiendo public o private en su declaración.

using System; namespace ConsoleAppVisibilitat { class Simple { public int Var1=10;



private int Var2=20; //local public int Var3=30; } class Class1 { static void Main(string[] args) { Simple s = new Simple(); Console.WriteLine("Simple:"); Console.WriteLine("Var1={0}, Var3={1}",s.Var1, s.Var3); Console.ReadLine(); } } } static: Variable estática, existe durante toda la ejecución del programa. o S ólo e xis te una s ola copia de la misma s in ne ce s ida d de cre a r obje to

alguno. o Ha y que re fe rirs e a e lla us a ndo e l nombre comple to de l tipo a l que

pertenece. o No a fe cta a s uvis ibilida d

using System; namespace ConsoleAppVisibilitatSTAT { class Simple { public static int Var3=30; // pública // estàtica static int Var4=40; //privada i estàtica public void mostraVar4() { Console.WriteLine("Var4={0}", ++Var4); } } class Class1 { static void Main(string[] args) { Simple s = new Simple(); Simple k = new Simple(); Console.WriteLine("Simple:"); Console.WriteLine("Var3={0}",Simple.Var3++); Console.WriteLine("Var3={0}",Simple.Var3); s.mostraVar4(); k.mostraVar4(); Console.ReadLine();



} } } • Conversión entre tipos de datos. int intValor = 123; long longValor = intValor; // implícita de int a long intvalor = (int) longValor; // explícita de long a int con cast int x = 123456; long y = x; // implícita short z = (short)x; // explícita double d = 1.2345678901234; float f = (float)d; // explícita long l = (long)d; // explícita //uso de la classe Convert: int c=154; Console.WriteLine(Convert.ToString(c)); Conversión implícita. Ocurre de forma automática. Siempre tiene éxito. Nunca se pierde información en la conversión.

Conversión explícita. Requiere la realización del cast o el comando Convert.Toxxx(var) Puede no tener éxito. Puede perderse información en la conversión.

• Tabla de conversión implícita segura

Tipo Se convierte de forma segura a: Byte short, ushort, int, uint, long, ulong, float, double, decimal Sbyte short, int, long, float, double, decimal Short int, long, float, double, decimal Ushort int, uint, long, ulong, float, double, decimal Int long, float, double, decimal Uint long, ulong, float, double, decimal Long float, double, decimal Ulong float, double, decimal Float double Char ushort, int, uint, long, ulong, float, double,decimal



• Tipos definidos por el usuario: Enumeraciones o La s e nume ra cione s s e cre a n cua ndo s e ne ce s ita que una va ria ble

tome valores de una lista limitada no predefinida. o Tienen por tipo base números enteros. o P or de fe cto e mpie za la nume ra ción por 0. o Definición de una enumeración: enum

Color { Rojo=1, Verde=2, Azul=3 } o Uso de una enumeración:

Color colorPaleta = Color.Rojo; o colorPaleta = (Color)1; // Tipo int a tipo Color

o Visualización de una variable de enumeración: Console.WriteLine(“{0}”, colorPaleta.ToString()); // Muestra Rojo

o Usando enumeraciones el código queda más claro y fácil de mantener.

• Tipos definidos por el usuario: Estructuras

o Definición: struct Empleado { public string nombre; public int edad; public int Sueldo = 1200; // error, no permitido! public Empleado(string nom, int edad … ) } o Uso: Empleado empresaEmpleado, otroEmpleado; empresaEmpleado.Nombre = "Juan"; empresaEmpleado.edad = 23; otroEmpleado = empresaEmpleado; //asignación directa

o Todos los miembros se se inician por defecto a null o El método booleano Equals() permite comparar dos structs.

otroEmpleado.Equals(empresaEmpleado)

En C#, las variables se declaran con un tipo de datos y una etiqueta concretos. Si hasta ahora sólo ha utilizado lenguajes con tipos definidos de forma imprecisa como JScript, estará acostumbrado a emplear el mismo tipo "var" para todas las variables, pero en C# tiene que especificar si la variable es de tipo int, float, byte, short u otro cualquiera entre más de 20 tipos de datos diferentes. El tipo especifica, entre otras cosas, la cantidad de memoria exacta que se debe asignar para almacenar el valor cuando la aplicación se ejecuta. El lenguaje C# fuerza ciertas reglas al convertir una variable de un tipo en otro. Para obtener más información, vea Tipos de datos integrados (Visual C# Express).





C#

int answer = 42; string greeting = "Hello, World!"; double bigNumber = 1e100; System.Console.WriteLine("{0} {1} {2}", answer, greeting, bigNumber); • Arrays

o Los arrays son tipos de referencia derivados de System.Array o Sus índices comienzan en 0

Ejemplo: string[] a; // array de cadenas o El tipo de datos array viene dado por string[] o El nombre del array es una referencia al array o Para crear espacio para los elementos usar:

string[] a = new string[100]; • Los arrays se pueden inicializar directamente:

string[] animales = {"gato", "perro", "caballo"}; int[] a2 = {1, 2, 3};

• Arrays multidimensionales: string[,] ar = {{"perro","conejo"}, {"gato","caballo"}}; double[,] tempAnual = new double[12,31];

• El rango de los elementos del array es dinámico: i. Si se crea un nuevo array sobre el mismo se libera la memoria que

ocupaba y se pierde toda la información que contenia. • Información sobre un array:

i. Dimensiones: .Rank ii. Número total de elementos del array: .Length iii. Número de elementos de la dimensión d: .GetLength(d)

5. Índice superior einferior: . GetLowerBound(d); .GetUpperBound(d); (d=dimensión, desde 0 hasta Rank-1) Saber si es un array: if (a is Array)

• Recorrido de los elementos de un array sin conocer sus índices foreach (string a in animales) Console.WriteLine(a);

• Operaciones de la clase Array: Copy( ); Sort( ); ...

• Manipulación de cadenas o Los tipos char y string permiten manipular caracteres. o Una variable char puede contener cualquier carácter Unicode o Manipulacion de caracteres:

char.IsDigit(…);char.IsLetter(…);char.IsPunctuation(…);char.ToUpper(…);char.ToLower(…),char.ToString(…);..., etc.



o Una variable tipo string es una referencia al lugar donde se guarda la cadena.

o Cada vez que se modifica el valor de la cadena se asigna un nuevo bloque de memoria y se libera el anterior.

o Concatenación: Nuevo operador + (no existe en C, C++) o se puede usar también el método: String.Concat() string a, b; a="Programació "; b=“amb C#"; Console.WriteLine(“Usant operador + en {0}", a+b); Console.WriteLine(" Usant concat en {0}", string.Concat(a, b));

IDENTIFICAR LOS TIPOS DE DATOS QUE EXISTEN EN VISUAL NET:

En este tema se describen algunas de las similitudes y diferencias principales en cómo se representan y asignan los datos, y se recolectan los elementos no utilizados en Java y en C#.

• Tipos de datos compuestos.

El concepto de clase como tipo de datos compuesto de campos, métodos y eventos es similar en Java y C#. (La herencia de clases se describe independientemente en el tema titulado Herencia y clases derivadas (C# y Java).) C# introduce el concepto de estructura como tipo de datos compuesto asignado por pila que no admite la herencia. En la mayoría de los otros aspectos, las estructuras son muy similares a las clases. Las estructuras proporcionan una manera ligera de agrupar campos y métodos relacionados para el uso en los bucles de pequeñas dimensiones y otros escenarios donde el rendimiento es crucial.

C# permite crear un método de destructor al que se llama antes de que se destruyan las instancias de una clase. En Java, se puede utilizar un método finalize para contener código que limpia los recursos antes de que se recolecten los elementos no utilizados del objeto. En C#, el que realiza esta función es el destructor de clase. El destructor se parece a un constructor sin los argumentos y con un carácter de tilde delante (~).

• Tipos de datos integrados.

C# proporciona todos los tipos de datos que están disponibles en Java y agrega compatibilidad para los números sin signo y un nuevo tipo de punto flotante de 128 bits de alta precisión.





Para cada tipo de datos primitivo en Java, la biblioteca de clases principal proporciona una clase contenedora, que lo representa como un objeto de Java. Por ejemplo, la clase Int32 contiene el tipo de datos int y la clase Double contiene el tipo de datos double.

Por otro lado, todos los tipos de datos primitivos en C# son objetos en el espacio de nombres System. Para cada tipo de datos, se proporciona un nombre corto o alias. Por ejemplo, int es el nombre corto correspondiente a System.Int32 y double es la forma abreviada de System.Double.

En la tabla siguiente se proporciona la lista de tipos de datos de C# y sus alias. Como puede ver, los primeros ocho de estos tipos corresponden a los tipos primitivos disponibles en Java. Sin embargo, tenga en cuenta que el tipo boolean de Java se denomina bool en C#.

Nombre corto

Clase .NET Tipo Ancho Intervalo (bits)

byte Byte Entero sin signo 8 0 a 255 sbyte SByte Entero con signo 8 -128 a 127

int Int32 Entero con signo 32 -2.147.483.648 a 2.147.483.647

uint UInt32 Entero sin signo 32 0 a 4294967295 short Int16 Entero con signo 16 -32.768 a 32.767

ushort UInt16 Entero sin signo 16 0 a 65535

long Int64 Entero con signo 64 -922337203685477508 a 922337203685477507

ulong UInt64 Entero sin signo 64 0 a 18446744073709551615

float Single

Tipo de punto flotante de precisión simple

32 -3,402823e38 a 3,402823e38

double Double

Tipo de punto flotante de precisión doble 64 -1,79769313486232e308 a

1,79769313486232e308

char Char Un carácter Unicode 16 Símbolos Unicode utilizados en el texto

bool Boolean Tipo Boolean lógico 8 True o false

object Object

Tipo base de todos los otros tipos

string String Una secuencia de caracteres

decimal Decimal

Tipo preciso fraccionario o integral, que puede representar números decimales con 29 dígitos significativos

128 ±1.0 × 10e−28 a ±7.9 × 10e28


http://msdn.microsoft.com/es-es/library/system.int32%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/system.double%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/678hzkk9%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/system%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/system.byte%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/system.sbyte%28v=vs.90%29.aspx


http://msdn.microsoft.com/es-es/library/system.uint32%28v=vs.90%29.aspx





http://msdn.microsoft.com/es-es/library/system.single%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/system.double%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/system.char%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/system.boolean%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/system.object%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/system.string%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/system.decimal%28v=vs.90%29.aspx


Dado que C# representa todos los tipos de datos primitivos como objetos, es posible llamar a un método de objeto de un tipo de datos primitivo. Por ejemplo:

C#

static void Main()

{

int i = 10;

object o = i;

System.Console.WriteLine(o.ToString());

}

Esto se logra con la ayuda de las conversiones automáticas boxing y unboxing. Para obtener más información, vea Conversión boxing y unboxing (Guía de programación de C#).

• Constantes.

Java y C# proporcionan la capacidad para declarar una variable cuyo valor se especifica en tiempo de compilación y no se puede cambiar en tiempo de ejecución. Java utiliza el modificador de campo final para declarar este tipo de variable, mientras que C# utiliza la palabra clave const. Además de const, C# proporciona la palabra clave readonly para declarar variables a las que se puede asignar un valor una vez en tiempo de ejecución, ya sea en la instrucción de declaración o en otra parte del constructor. Después de la inicialización, el valor de una variable readonly no puede cambiar. Un escenario en el que las variables readonly son útiles es cuando los módulos que se han compilado independientemente tienen que compartir datos como un número de versión. Si el módulo A se actualiza y se vuelve a compilar con un nuevo número de versión, el módulo B se puede inicializar con ese nuevo valor constante sin tener que volver a compilarlo.

• Enumeraciones.

Las enumeraciones se utilizan para agrupar constantes con nombres en forma similar a la forma en que se utilizan en C y C++; no están disponibles en Java. En el ejemplo siguiente se define una enumeración Color sencilla.

C#

public enum Color


http://msdn.microsoft.com/es-es/library/yz2be5wk%28v=vs.90%29.aspx





{ Green, //defaults to 0 Orange, //defaults to 1 Red, //defaults to 2 Blue //defaults to 3 }

También se pueden asignar valores integrales a las enumeraciones, tal como se muestra en la siguiente declaración de enumeración:

C#

public enum Color2 { Green = 10, Orange = 20, Red = 30, Blue = 40 }

En el siguiente ejemplo de código se llama al método GetNames del tipo Enum para mostrar las constantes disponibles para una enumeración. Luego, asigna un valor a una enumeración y muestra el valor.

C#

class TestEnums { static void Main() { System.Console.WriteLine("Possible color choices: "); //Enum.GetNames returns a string array of named constants for the enum. foreach(string s in System.Enum.GetNames(typeof(Color))) { System.Console.WriteLine(s); } Color favorite = Color.Blue; System.Console.WriteLine("Favorite Color is {0}", favorite); System.Console.WriteLine("Favorite Color value is {0}", (int) favorite); }


http://msdn.microsoft.com/es-es/library/system.enum.getnames%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/system.enum%28v=vs.90%29.aspx


}

• Resultado.

Possible color choices: Green Orange Red Blue Favorite Color is Blue Favorite Color value is 3

• Cadenas.

Los tipos de cadena en Java y C# denotan un comportamiento similar con leves diferencias. Ambos tipos de cadena son inmutables, lo que significa que los valores de las cadenas no se pueden cambiar una vez que se han creado las cadenas. En ambos casos, los métodos que parecen modificar el contenido real de una cadena crean en realidad una nueva cadena que se devolverá como resultado, dejando la cadena original sin cambios. El proceso de comparación de los valores de cadena es diferente en C# y Java. Para comparar los valores de cadena en Java, los desarrolladores deben llamar al método equals de un tipo string, mientras que el operador == compara los tipos de referencia de forma predeterminada. En C#, los desarrolladores pueden utilizar los operadores == o != para comparar directamente valores de cadena. Aunque una cadena es un tipo de referencia en C#, los operadores == y != compararán, en forma predeterminada, los valores de las cadenas en lugar de las referencias. Como en Java, los desarrolladores de C# no deben usar el tipo string para concatenar cadenas con el fin de evitar la sobrecarga de crear nuevas clases de cadenas cada vez que se concatene la cadena. En su lugar, los desarrolladores pueden utilizar la clase StringBuilder, que es funcionalmente equivalente a la clase StringBuffer de Java.

• Literales de cadena.

C# proporciona la posibilidad de evitar el uso de secuencias de escape como "\t" para la ficha o "\" para los caracteres de barra diagonal inversa dentro de las constantes de cadena. Para ello, simplemente declare la cadena textual mediante el símbolo @ para preceder la asignación del valor de cadena. Los siguientes ejemplos muestran cómo utilizar los caracteres de escape y cómo asignar literales de cadena:

C#

static void Main()


http://msdn.microsoft.com/es-es/library/system.text.stringbuilder%28v=vs.90%29.aspx


{ //Using escaped characters: string path1 = "\\\\FileShare\\Directory\\file.txt"; System.Console.WriteLine(path1); //Using String Literals: string path2 = @"\\FileShare\Directory\file.txt"; System.Console.WriteLine(path2); }

• Conversión y conversión de tipos.

Java y C# siguen reglas similares para la conversión automática y la conversión de tipos de datos.

Al igual que Java, C# admite conversiones de tipo implícitas y explícitas. En el caso de conversiones de ampliación, las conversiones son implícitas. Por ejemplo, la siguiente conversión de int a long es implícita, como en Java:

C#

int int1 = 5;

long long1 = int1; //implicit conversion

La siguiente es una lista de conversiones implícitas entre los tipos de datos de .NET Framework:

Tipo de origen Tipo de destino Byte short, ushort, int, uint, long, ulong, float, double o decimal Sbyte short, int, long, float, double o decimal

Int long, float, double o decimal Uint long, ulong, float, double o decimal

Short int, long, float, double o decimal Ushort int, uint, long, ulong, float, double o decimal Long float, double o decimal Ulong float, double o decimal Float double Char ushort, int, uint, long, ulong, float, double o decimal

Puede convertir el tipo de expresiones que desee convertir explícitamente usando la misma sintaxis que en Java:

C#



long long2 = 5483;

int int2 = (int)long2; //explicit conversion

La tabla siguiente muestra las conversiones explícitas.

Tipo de origen Tipo de destino Byte sbyte o char Sbyte byte, ushort, uint, ulong o char

Int sbyte, byte, short, ushort, uint, ulong o char Uint sbyte, byte, short, ushort, int o char

Short sbyte, byte, ushort, uint, ulong o char Ushort sbyte, byte, short o char Long sbyte, byte, short, ushort, int, uint, ulong o char Ulong sbyte, byte, short, ushort, int, uint, ulong o char Float sbyte, byte, short, ushort, int, uint, long, ulong, char o decimal

Double sbyte, byte, short, ushort, int, uint, long, ulong, char o decimal Char sbyte, byte o short

Decimal sbyte, byte, short, ushort, int, uint, long, ulong, char, float o double

• Tipos de referencia y valor.

C# admite dos tipos de variables:

• Tipos de valor.

Estos son los tipos de datos primitivos integrados, como char, int y float, así como también los tipos definidos por el usuario declarado con la estructura.

• Tipos de referencia.

Clases y otros tipos de datos complejos que se construyen a partir de los tipos primitivos. Las variables de estos tipos no contienen una instancia del tipo, sino sólo una referencia a una instancia.

Si se crean dos variables del tipo de valor, i y j, como se muestra a continuación, i y j son completamente independientes entre sí:

C#

int i = 10;

int j = 20;

Tienen ubicaciones de memoria independiente:



Si cambia el valor de una de estas variables, la otra no se verá afectada de forma natural. Por ejemplo, si tiene una expresión como la siguiente, aún no existe ninguna conexión entre las variables:

C#

int k = i;

Es decir, si cambia el valor de i, k permanecerá con el valor que tenía i en el momento de la asignación.

C#

i = 30;

System.Console.WriteLine(i.ToString()); // 30

System.Console.WriteLine(k.ToString()); // 10

Sin embargo, los tipos de referencia actúan de forma diferente. Por ejemplo, podría declarar dos variables de la siguiente forma:

C#

Employee ee1 = new Employee();

Employee ee2 = ee1;

Ahora, puesto que las clases son tipos de referencia de C#, ee1 se conoce como referencia a Employee. La primera de las dos líneas anteriores crea una instancia de Employee en memoria y define ee1 para que haga referencia a ella. Así, cuando se establece ee2 para que sea igual a ee1, el primero contiene un duplicado de la referencia a la clase de la memoria. Si ahora cambia las propiedades de ee2, las propiedades de ee1 reflejan estos cambios, ya que ambas apuntan al mismo objeto de la memoria, tal como aparece a continuación:



Conversiones boxing y unboxing

El proceso de convertir el tipo de un valor en el tipo de una referencia se denomina conversión boxing. El proceso inverso, convertir el tipo de una referencia en el tipo de un valor, se denomina conversión unboxing. Esto queda reflejado en el ejemplo de código siguiente:

C#

int i = 123; // a value type

object o = i; // boxing

int j = (int)o; // unboxing

Java requiere que esas conversiones se realicen manualmente. Los tipos de datos primitivos se pueden convertir en objetos de clases contenedoras construyendo esos objetos o aplicando la conversión boxing.

De igual manera, los valores de los tipos de datos primitivos se pueden extraer de los objetos de las clases contenedoras llamando a un método adecuado de estos objetos, o realizar una conversión unboxing. Para obtener más información acerca de las conversiones boxing y unboxing, vea Conversión boxing y unboxing (Guía de programación de C#).





ANALIZAR LA IMPORTANCIA DE UNA ESTRUCTURA CONDICIONAL. • Que es una estructura?

es la

SINTAXIS *(Bnf + ebnf + diagramas de sintaxis) Sumado a la SEMÁNTICA *Operacional (aproximacion utulizada aqui) *Formal (a traves de mecanismos rigurosos y exactos) *Semantica operacional: se describe el significado de cada construccion del lenguaje en terminos de las operaciones correspondientes en un proceso abstracto. Sintáxis de los lenguajes de programación. La sintaxis de un lenguaje de programación es la estructura en que se organizan los distintos elementos sintácticos, como espacios, identificadores, operadores, etc. Es decir el orden que tienen unos con respecto a otros. Una sintaxis se evalúa según varios criterios: que sea fácil de leer, de escribir, de verificar (chequear en busca de errores), fácil de traducir y que carezca de ambigüedad. Esta última significa que un mismo código puede tener 2 o más interpretaciones o traducciones posibles, en cuyo caso no se puede decidir que alternativa elegir. Los elementos de la sintáxis son: alfabeto, identificadores (nombres de variables, constantes, etc.), símbolos de operadores (+,-,etc.), espacios en blanco, delimitadores y corchetes, palabras pregonadas (palabras que se pueden omitir sin alterar el significado), palabras clave y reservadas (propias del lenguaje), comentarios y expresiones.

El principal problema de una sintáxis es cómo se la define. Para esto existen metalenguajes que permiten definir la manera en que se combinan los símbolos y elementos. Estos metalenguajes o notaciones formales son un conjunto de reglas que especifican el modelo de construcción de las cadenas aceptadas por el lenguaje. Es decir que un metalenguaje es un lenguaje que define a un lenguaje de programación. Sus elementos son símbolo distinguido, metasímbolos y metavariables.

Símbolo distinguido: Punto de partida para la generación de todas las cadenas.


http://www.monografias.com/Computacion/Programacion/

http://www.monografias.com/trabajos15/todorov/todorov.shtml%23INTRO

http://www.monografias.com/trabajos12/eticaplic/eticaplic.shtml

http://www.monografias.com/trabajos12/guiainf/guiainf.shtml%23HIPOTES

http://www.monografias.com/trabajos36/signos-simbolos/signos-simbolos.shtml

http://www.monografias.com/trabajos35/concepto-de-lenguaje/concepto-de-lenguaje.shtml

http://www.monografias.com/trabajos/adolmodin/adolmodin.shtml

http://www.monografias.com/trabajos35/materiales-construccion/materiales-construccion.shtml

http://www.monografias.com/trabajos16/desarrollo-del-lenguaje/desarrollo-del-lenguaje.shtml

http://www.monografias.com/Computacion/Programacion/


Metasímbolos: ( | (o), ::= (es), ).Metavariables: Pueden ser terminales o no terminales.

- Terminales: Son palabras que forman los símbolos no terminales. - No terminales: Son identificadores que tienen un definición hecha con más

metavariables, de manera que es posible reemplazarlas por sus definiciones.

Otra manera de llamarlo a este tipo de gramáticas es "gramáticas BNF" (Backus Naur Form), que son un metalenguaje que define las reglas de formación de las cadenas aceptadas por un lenguaje de programación. Fueron inventadas por Backus Naur para el desarrollo del lenguaje de programación Algol 60.

Ejemplo: ::= {}+ |

{}+

Existe una representación visual de una gramática BNF, que son los grafos sintácticos. Esots usan flechas, círculos y rectángulos. Sus ventajas son que son más fáciles de entender para el ojo humano.

Una vez que tenemos definada la sintáxis de nuestro lenguaje, el compilador deberá determinar si las cadenas de texto ingresadas por los usuarios son válidas de acuerdo a esta sintáxis. Para esto se utilizan árboles de análisis sintáctico y algoritmos de parsing.

Semántica.

La semántica de un lenguaje de programación se refiere al significado que adoptan las distintas sentencias, expresiones y enunciados de un programa. La semántica engloba aspectos sensibles al contexto, a diferencia de la sintaxis que considera aspectos libres de contexto.

Los principales elementos de la semántica son:

Variables: se refieren a locaciones de memoria ligadas a un nombre y a un tipo.

Valores y referencias: los valores son el estado de determinada celda o grupo de celdas de la memoria, mientras que las referencias indican la posición de esa celda en memoria. Estos 2 conceptos están muy involucrados con los punteros. La mayoría de los lenguajes los soportan, aunque son una conocida fuente de errores de programación.


http://www.monografias.com/trabajos12/desorgan/desorgan.shtml

http://www.monografias.com/trabajos14/ortografia/ortografia.shtml

http://www.monografias.com/trabajos15/organizac-gral/organizac-gral.shtml%23TEORIA

http://www.monografias.com/trabajos13/libapren/libapren.shtml

http://www.monografias.com/trabajos15/composicion-follaje/composicion-follaje.shtml

http://www.monografias.com/trabajos11/metods/metods.shtml%23ANALIT

http://www.monografias.com/trabajos15/algoritmos/algoritmos.shtml

http://www.monografias.com/trabajos29/semantica-conectores-aplicaciones-obras-literarias/semantica-conectores-aplicaciones-obras-literarias.shtml

http://www.monografias.com/trabajos13/memor/memor.shtml

http://www.monografias.com/trabajos14/nuevmicro/nuevmicro.shtml

http://www.monografias.com/trabajos12/elorigest/elorigest.shtml

http://www.monografias.com/trabajos14/dinamica-grupos/dinamica-grupos.shtml

http://www.monografias.com/trabajos16/memorias/memorias.shtml


Expresiones: Son construcciones sintácticas que permiten combinar valores con operadores y producir nuevos valores. Son los elementos de los que se componen los enunciados. Las expresiones pueden ser aritméticas (a +b*c), relacionales (a a), lógicas (a && b || c)

o condicionales (if (a*b > 2)...). Cada una de estas tiene una semántica especifica que la define. Por ejemplo en una expresión aritmética el tipo esperado es numérico (esto es int, long, etc.), los operadores deben ser +,-,*, /; y las funciones utilizadas dentro de ésta deben retornar valores numéricos.

Semántica estática. Gramática de atributos: Las gramáticas de atributos son más poderosas que las BNF porque permiten formalizar aspectos sensibles al contexto.

Por ejemplo, el chequeo de tipos depende del contexto porque debemos saber el tipo esperado y el actual y determinar si son compatibles. El tipo esperado lo obtenemos del contexto analizando la definición de la variable. Si la variable num1 está definida de tipo String, y más adelante le queremos asignar el valor 1000, se producirá un error de tipo.

La gramática de atributos de compone de:

Atributos: o heredados: son los que se obtienen de un elemento más general. Esquema de arriba hacia abajo. Por ejemplo, number y float. En este caso float heredará los atributos de number e incorporará nuevos atributos propios de su tipo.

Sintetizados: se conocen a partir de los subelementos, como ser un subrango. Esquema de abajo hacia arriba, opuesto a los atributos heredados.

Intrínsecos: Estos atributos se obtienen de tablas externas, fuera del árbol de derivación.

Condiciones: Son hechos que se evalúan si suceden o no.

Por ejemplo, if(num>=20) ...

Reglas: A partir de un conjunto de condiciones se forman las reglas.

Por ejemplo:



http://www.monografias.com/trabajos7/mafu/mafu.shtml

http://www.monografias.com/trabajos5/estat/estat.shtml



Teorema del programa estructurado

El teorema del programa estructurado es un resultado en la teoría de lenguajes de programación. Establece que toda función computable puede ser implementada en un lenguaje de programación que combine sólo tres estructuras lógicas. Esas tres formas (también llamadas estructuras de control) específicamente son:

1. Secuencia: ejecución de una instrucción tras otra. 2. Selección: ejecución de una de dos instrucciones (o conjuntos), según el

valor de una variable booleana. 3. Iteración: ejecución de una instrucción (o conjunto) mientras una variable

booleana sea 'verdadera'. Esta estructura lógica también se conoce como ciclo o bucle.

Este teorema demuestra que la instrucción GOTO no es estrictamente necesaria y que para todo programa que la utilice existe otro equivalente que no hace uso de dicha instrucción.

Los científicos de la computación usualmente acreditan el teorema a un artículo de 1966 escrito por Corrado Böhm y Giuseppe Jacopini. Sin embargo, David Harel rastreó sus orígenes hasta la descripción de 1946 de la arquitectura de von Neumann y el teorema de la forma normal de Kleene.

La demostración de Böhm-Jacopini describe cómo construir diagramas de flujo estructurados a partir de cualquier digrama de flujo, usando los bits de una variable entera extra para dar seguimiento a la información que el programa original representa mediante puntos de entrada en el código. Esta construcción estuvo basada en el lenguaje de programación P′′ de Böhm. La demostración de Böhm-Jacopini no esclareció la cuestión sobre cuándo convendría usar programación estructurada para el desarrollo de software, en parte porque la construcción ofuscaba el código del programa en lugar de mejorarlo. Por otro lado, fue el punto de partida para iniciar el debate. Edsger Dijkstra escribió una importante carta titulada "La sentencia Go To considerada dañina" en el año 1968. Posteriores estudios agregaron aproximaciones más prácticas a la


http://es.wikipedia.org/wiki/Teor%C3%ADa_de_lenguajes_de_programaci%C3%B3n

http://es.wikipedia.org/wiki/Teor%C3%ADa_de_lenguajes_de_programaci%C3%B3n

http://es.wikipedia.org/wiki/Funci%C3%B3n_computable

http://es.wikipedia.org/wiki/Estructuras_de_control

http://es.wikipedia.org/wiki/Tipo_de_dato_l%C3%B3gico

http://es.wikipedia.org/wiki/Corrado_B%C3%B6hm

http://es.wikipedia.org/w/index.php?title=Giuseppe_Jacopini&action=edit&redlink=1

http://es.wikipedia.org/w/index.php?title=David_Harel&action=edit&redlink=1

http://es.wikipedia.org/w/index.php?title=David_Harel&action=edit&redlink=1

http://es.wikipedia.org/wiki/Arquitectura_de_von_Neumann

http://es.wikipedia.org/wiki/Arquitectura_de_von_Neumann

http://es.wikipedia.org/wiki/Stephen_Kleene

http://es.wikipedia.org/wiki/Bit

http://en.wikipedia.org/wiki/P%E2%80%B2%E2%80%B2

http://es.wikipedia.org/wiki/Programaci%C3%B3n_estructurada

http://es.wikipedia.org/wiki/Edsger_Dijkstra

http://en.wikipedia.org/wiki/Go_To_Statement_Considered_Harmful

http://es.wikipedia.org/wiki/1968


demostración de Böhm-Jacopini, que mantenían o mejoraban la claridad del programa original.

Ventajas de la programación estructurada

Ventajas de la programación estructurada comparada con el modelo anterior (hoy llamado despectivamente código espagueti).

• Los programas son más fáciles de entender, pueden ser leídos de forma secuencial y no hay necesidad de hacer engorrosos seguimientos en saltos de líneas (GOTO) dentro de los bloques de código para intentar entender la lógica.

• La estructura de los programas es clara, puesto que las instrucciones están más ligadas o relacionadas entre sí.

• Reducción del esfuerzo en las pruebas y depuración. El seguimiento de los fallos o errores del programa ("debugging") se facilita debido a su estructura más sencilla y comprensible, por lo que los errores se pueden detectar y corregir más fácilmente.

• Reducción de los costos de mantenimiento. Análogamente a la depuración, durante la fase de mantenimiento, modificar o extender los programas resulta más fácil.

• Los programas son más sencillos y más rápidos de confeccionar. • Se incrementa el rendimiento de los programadores, comparado con la

forma anterior que utiliza GOTO.

Programación estructurada de bajo nivel.

En un bajo nivel, los programas estructurados con frecuencia están compuestos de simples estructuras de flujo de programa jerárquicas. Estas son secuencia, selección y repetición:

• "Secuencia" se refiere a una ejecución ordenada de instrucciones. • En "selección", una de una serie de sentencias es ejecutada dependiendo

del estado del programa. Esto es usualmente expresado con palabras clave como if..then..else..endif, switch, o case. En algunos lenguajes las palabras clave no se puede escribir textualmente, pero debe ser delimitada (stropped).

• En la "repetición" se ejecuta una sentencia hasta que el programa alcance un estado determinado, o las operaciones han sido aplicadas a cada elemento de una colección. Esto es usualmente expresado con palabras clave como while, repeat, for o do..until. A menudo se recomienda que cada bucle sólo debe tener un punto de entrada (y en la programación estructural original, también sólo un punto de salida, y pocos lenguajes refuerzan esto).


http://es.wikipedia.org/wiki/C%C3%B3digo_espagueti


Representaciones gráficas de los tres patrones básicos. Los diagramas de caja (azules) fueron inventados para la nueva teoría, y aquí se pueden ver sus equivalentes en los más usados diagramas de flujo de control

Un lenguaje es descrito como estructurado en bloque cuando tiene una sintaxis para encerrar estructuras entre palabras clave tipo corchete, como una sentencia if..fi en ALGOL 68, o una sección de código entre corchetes BEGIN..END, como en PL/I - o la de llaves {...} de C y muchos otros lenguajes posteriores.

Estructuras estáticas

Tipos primitivos:

Tipos numéricos:

Enteros: se representan en memoria como una secuencia de bits que de acuerdo a su posición y valor (0 o 1) simbolizan el valor.

Flotantes: existen 2 implementaciones básicas, flotantes de 32 y 64 bits. Se valor se representa por 3 partes que son el signo, el exponente y la mantisa. En los de 32 bits, el exponente ocupa 8 bits y el resto la mantisa y el signo. En los de 64 bits el exponente ocupa 11 bits.

Carácteres: Cada secuencia de bits tiene un símbolo asociado. Originalmente ocupan 8 bits como representación ASCII. Luego la representación se extendió a 16 bits como Unicode para almacenar más cantidad de símbolos (de otros idiomas). Esta representación facilita la internacionalización.

Booleanos: son un tipo relativamente nuevo. Se desperdicia espacio de almacenamiento porque los valores verdadero y falso se pueden representar con un solo bit, pero el mínimo permitido en los sistemas actuales son 8 bits. Posibilidad de empaquetamiento para vectores de booleanos. Permiten operaciones lógicas. Aportan mayor legibilidad al código y más confiabilidad (menos posibilidad de confusiones).

Tipos definidos por el usuario:


http://es.wikipedia.org/wiki/Diagrama_de_flujo

http://es.wikipedia.org/w/index.php?title=ALGOL_68&action=edit&redlink=1

http://es.wikipedia.org/wiki/PL/I

http://es.wikipedia.org/wiki/Lenguaje_C

http://www.monografias.com/trabajos12/comptcn/comptcn.shtml

http://www.monografias.com/trabajos12/dispalm/dispalm.shtml

http://www.monografias.com/trabajos11/teosis/teosis.shtml

http://www.monografias.com/trabajos35/vectores/vectores.shtml

http://commons.wikimedia.org/wiki/File:Structured_program_patterns.png

http://es.wikipedia.org/wiki/Archivo:Structured_program_patterns.png


Tipos enumerados: se pueden representar internamente con valores numéricos secuenciales, aunque las enumeraciones sean palabras u otros datos.

sub-intervalos: al ser menos cantidad de valores, necesitan menos espacio de almacenamiento. Posibilidad de empaquetarlos.

Tipos estructurados:

Arreglos: almacenan tipos iguales. El acceso a sus elementos es, en general, por posición. Los arreglos pueden ser estáticos o dinámicos, y redimensionables o no. Los arreglos se almacenan de manera continua en memoria, salvo que sean redimensionables.

Registros: Pueden almacenar distintos campos dentro de sí, incluidos más registros y arreglos. Son muy útiles para mejorar la legibilidad y facilidad de escritura. En Pascal y en Ada también existen los registros variantes. En C se usa la palabra reservada "struct" para definirlos.

Unión: es una locación de memoria asociada a muchos tipos de datos, o sea que puede ser interpretada de distintas maneras. La provee el lenguaje C.

Conjunto: es una estructura de datos con muchos elementos distintos, es decir que no los hay repetidos. Los conjuntos permiten hacer operaciones de unión, intersección y diferencia entre ellos.

Estructuras dinámicas: son ideales para modelar situaciones de la vida real, con capacidades excepcionales de flexibilidad.

Listas: almacenan elementos de distinto tipo. Son redimensionables e ideales para insertar y eliminar elementos. Pueden ser simple o doblemente enlazadas. Se implementan con una referencia al siguiente elemento, que puede estar en cualquier locación de memoria. Con 2 referencias, una direcciona al elemento anterior y otra al siguiente. Óptimas para recorrerlas de arriba hacia abajo y viceversa.

Árboles: cada nodo almacena 2 o más apuntadores a sus nodos hijos. Tenemos muchos tipos de árboles, como árboles binarios, B+, B*, etc. Además pueden tener una referencia al nodo padre (uno solo) y esto permite recorrer el árbol de abajo hacia arriba.

Grafos: cada nodo almacena una o varias referencias a los nodos con los que está conectado. Si el grafo es dirigido (con dirección de lectura) hay que proyectar almacenar esta información. Los grafos son útiles en aplicaciones que usan mapas de ciudades, sistemas operativos, videojuegos, etc. Requieren


http://www.monografias.com/trabajos7/regi/regi.shtml

http://www.monografias.com/trabajos16/metodo-lecto-escritura/metodo-lecto-escritura.shtml

http://www.monografias.com/trabajos11/basdat/basdat.shtml

http://www.monografias.com/trabajos4/lenguajec/lenguajec.shtml

http://www.monografias.com/trabajos10/historix/historix.shtml

http://www.monografias.com/trabajos15/direccion/direccion.shtml

http://www.monografias.com/trabajos14/textos-escrit/textos-escrit.shtml

http://www.monografias.com/trabajos56/lectura-mapas-y-cartas/lectura-mapas-y-cartas.shtml

http://www.monografias.com/Computacion/Sistemas_Operativos/

http://www.monografias.com/trabajos35/videojuegos-piratas-lima/videojuegos-piratas-lima.shtml


algoritmos especiales para recorrerlos ya que es una de las estructuras dinámicas más complejas.

Chequeo estático y dinámico de tipos: Los chequeos estáticos comprueban la consistencia de tipos en tiempo de compilación, es decir, estáticamente. Es más seguro porque no genera el ejecutable hasta que no haya ningún error de tipo. Es menos flexible que el dinámico. Los lenguajes con chequeo estático son fuertemente tipados, esto es que el chequeo se realiza de una manera exhaustiva.

El chequeo dinámico, por su parte, es más flexible pero mucho menos seguro y confiable que el estático. Aumenta la sobrecarga durante la ejecución. El chequeo se realiza en tiempo de ejecución.

Abstracción de datos: La abstracción de datos permite dividir un gran problema en problemas menores para simplificar, definir interfaces de acceso para la manipulación del dato, y oscurecer la implementación de forma de hacerla transparente para el usuario.

Una manera de lograr cierto nivel de abstracción son los "tipos genéricos". Son abstracciones de datos que permiten ser usados en distintos contextos y usar una misma implementación para distintos tipos y estructuras de datos. Ej: En Java están implementados con el uso de la clase Object, Number, Container, etc. Ahorra trabajo y esfuerzo al programador, a la vez que simplifican la implementación.

Los "tipos parametrizados" son otra manera de generar abstracción.. Se construyen en base a parámetros.

Polimorfismo: El polimorfismo está basado en el concepto de la manipulación de entidades de distinto tipo. Un lenguaje polimórfico es aquel que sus entidades pueden estar ligadas a más de un tipo. Una función es polimórfica si acepta operandos de distintos tipos. Y un tipo es polimórfico si sus operaciones son polimórficas.

Coerción, conversión y compatibilidad: La coerción es la conversión automática de un tipo a otro. Ocurre cuando el tipo en cuestión es un subtipo de otro (o una subclase en el paradigma orientado a objetos). El principio que gobierna las coerciones es no perder información. Las conversiones son transformaciones del tipo de una entidad a otro. Por ejemplo, en muchos lenguajes las asignaciones de enteros de 32 bits a enteros de 16 bits requieren la acción del programador porque se puede perder información (no hay manera de representar el rango de 32 bits con sólo 16).


http://www.monografias.com/trabajos5/segu/segu.shtml

http://www.monografias.com/trabajos901/debate-multicultural-etnia-clase-nacion/debate-multicultural-etnia-clase-nacion.shtml

http://www.monografias.com/trabajos34/el-trabajo/el-trabajo.shtml

http://www.monografias.com/trabajos10/teca/teca.shtml

http://www.monografias.com/trabajos7/mafu/mafu.shtml

http://www.monografias.com/trabajos16/paradigmas/paradigmas.shtml%23queson

http://www.monografias.com/trabajos35/categoria-accion/categoria-accion.shtml


Inferencia de tipos: en algunos lenguajes como ML es posible la inferencia de tipos. Al no especificarse el tipo de un dato, es inferido a partir del uso que se hace de él. Es decir, de las funciones que lo manipulan. Ejemplo en ML: fun resto(n) = n mod 2.

En esta función el tipo del parámetro no está indicado, pero como la función mod se aplica únicamente a tipos enteros se infiere este tipo para "n". En algunos casos es muy difícil hacer la inferencia debido al alto polimorfismo de la función usada (a la cantidad de tipos que acepta). Por ejemplo en fun (a,b) = a+b; es difícil determinarlo porque "+" puede sumar números o concatenar cadenas de texto.

Instrucciones.

Generalmente disponemos de 2 tipos de instrucciones, asignación y de control.

La asignación puede ser simple, múltiple o condicional. Se puede realizar en las declaraciones. Algunos lenguajes permiten asignación múltiple, mientras que otros sólo admiten la simple. Por su parte, así como disponemos de estructuras para controlar la evaluación de las expresiones y la ejecución de las unidades, también las tenemos para controlar instrucciones. Estructuras de control a nivel instrucción:

Secuencia:: Es la ejecución en orden, una sentencia después de la anterior. Se puede modificar con saltos incondicionales como el GOTO, aunque el uso excesivo de este altera demasiado la secuencialidad del código y lo hace ilegible.

Selección:: Probablemente es una de las primeras estructuras usadas. Permiten bifurcar o seleccionar el código a ejecutar de acuerdo al valor lógico que resulta de evaluar una condición. Generalmente se implementa con la palabra reservada "if...else...".

Iteración:: La iteración evita repeticiones de código innecesarias. Disponemos de iteraciones condicionales e incondicionales. Las primeras consumen más tiempo que las segundas debido a que se debe evaluar la condición en cada ciclo. Por su parte, las incondicionales se usan para recorrer vectores, matrices, etc.

Unidades.

Los subprogramas se dividen en dos categorías, procedimientos y funciones. La diferencia entre estos es que los procedimientos no retornan valores, sino que realizan una acción. Por ejemplo, procesarArreglo(int[ ] ...). Las funciones


http://www.monografias.com/trabajos14/matriz-control/matriz-control.shtml

http://www.monografias.com/trabajos13/mapro/mapro.shtml


devuelven un valor que puede ser un tipo primitivo, y en algunos en lenguajes modernos pueden ser también objetos.

Un subprograma tiene 3 partes básicas, a saber: inicio, suspensión y control. El inicio puede producirse por una llamada desde el programa principal o desde otro subprograma. La suspensión se produce con la invocación de un subprograma. Cuando un programa o subprograma la hace, se suspende temporalmente mientras se ejecuta el subprograma invocado. Esto pasa porque generalmente es necesario procesar un conjunto de datos antes de hacer otro proceso, y no se puede comenzar el segundo sin la totalidad de los primeros datos procesados. Por otra parte, hay distintas maneras de controlar un subprograma, que pueden ser implícitas (excepciones) o explícitas (relación jerárquica, simétrica o paralela).

• ESTRUCTURAS SECUENCIALES. La estructura secuencial es aquella en la que una acción (instrucción) sigue a otra en secuencia. Las tareas se suceden de tal modo que la salida de una es la entrada de la siguiente y así sucesivamente hasta el fin del proceso. En Pseudocódigo una Estructura Secuencial se representa de la siguiente forma: PSEUDOCODIGO Nombre VARIABLES Nombre: Tipo De Dato CONSTANTES Nombre = Valor INICIO accion accion1 accion2 . . . accionN FIN En Diagrama de Flujo:


http://www.monografias.com/trabajos14/administ-procesos/administ-procesos.shtml%23PROCE


Ejemplo 1: Escriba un algoritmo que pregunte por dos números y muestre como resultado la suma de estos. Use Pseudocódigo y diagrama de flujos. PSEUDOCODIGO SUMAR VARIABLES Num1,Num2,Suma: Entero INICIO Escribir ('introduzca dos numeros') leer (Num1, Num2) Suma=Num1 + Num2 escribir ('La suma es:' , Suma) FIN

Ejemplo 2: Escriba un algoritmo que permita conocer el área de un triángulo a partir de la base y la altura. Exprese el algoritmo usando Pseudocódigo y diagrama de flujos.



PSEUDOCODIGO AREA VARIABLES Base, Altura: Entero INICIO Escribir ('ingrse la base') Leer (Base) Escribir ('Ingrese Altura') Leer (Altura) Escribir('el areadel triangulo es:' , (Base*Altura)/2 FIN

Expreciones lógicas. Sirven para plantear condiciones o comparaciones y dan como resultado un valor booleano verdadero o falso, es decir, se cumple o no se cumple la condición. Se pueden clasificar en simples y complejas. Las simples son las que usan operadores relacionales y las complejas las que usan operadores lógicos.

Ejemplos: Un ejemplo en el cual usamos el operador lógico AND sería: Una escuela aplica dos exámenes a sus aspirantes, por lo que cada uno de ellos obtiene dos calificaciones denotadas como C1 y C2. El aspirante que obtenga calificaciones mayores que 80 en ambos exámenes es aceptado; en caso contrario es rechazado.



En este ejemplo se dan las condiciones siguientes:

Si (C1 >= 80) y (C2 >= 80) entonces Escribir ("aceptado") Sino Escribir ("rechazado") Fin_si

Note que también usa operadores relacionales. Por lo general cuando hay operadores lógicos, éstos van acompañados de operadores relacionales. Un ejemplo usando el operador lógico OR sería:

Una escuela aplica dos exámenes a sus aspirantes, por lo que cada uno de ellos obtiene dos calificaciones denotadas como C1 y C2. El aspirante que obtenga una calificación mayor que 90 en cualquiera de los exámenes es aceptado; en caso contrario es rechazado.

En este caso se dan las condiciones siguientes:

Si (C1 >=90) or (C2 >=90) entonces Escribir ("aceptado") Sino Escribir ("rechazado") Fin_si

La instrucción equivale a OR ya que nos dice que puede ser en cualquiera de los exámenes no necesariamente en los dos. En el ejemplo 1 la palabra ambos equivalía a seleccionar la instrucción AND. Si la instrucción nos dijera que obtenga una nota en cualquiera de los exámenes pero no en ambos, nos estaría indicando una instrucción XOR que es un tipo de OR pero exclusivo. Es decir, no puede considerarse el caso en que tenga la misma nota en los dos exámenes, solo en uno de los dos.

Estructuras condicional. Estructura condicional simple.

Cuando se presenta la elección tenemos la opción de realizar una actividad o no realizar ninguna.




Podemos observar: El rombo representa la condición. Hay dos opciones que se pueden tomar. Si la condición da verdadera se sigue el camino del verdadero, o sea el de la derecha, si la condición da falsa se sigue el camino de la izquierda. Se trata de una estructura CONDICIONAL SIMPLE porque por el camino del verdadero hay actividades y por el camino del falso no hay actividades. Por el camino del verdadero pueden existir varias operaciones, entradas y salidas, inclusive ya veremos que puede haber otras estructuras condicionales.

Estructura condicional compuesta.

Cuando se presenta la elección tenemos la opción de realizar una actividad u otra. Es decir tenemos actividades por el verdadero y por el falso de la condición. Lo más importante que hay que tener en cuenta que se realizan las actividades de la rama del verdadero o las del falso, NUNCA se realizan las actividades de las dos ramas.


En una estructura condicional compuesta tenemos entradas, salidas, operaciones, tanto por la rama del verdadero como por la rama del falso.

Habitualmente en la vida nosotros tomamos decisiones tan simples como un si o un no. En informática no puede ser la excepción así que aquí tenemos a las Estructuras Secuenciales; esta estructura se encarga del Flujo del Programa, veamos un ejemplo:



José debe de viajar a la ciudad de Huancavelica desde la ciudad de lima tiene a las empresas de Transportes Ticllas y Expreso Molina. En E.T. Ticllas el Costo de Pasaje es de S/. 45.00 Nuevos Soles y en Expreso Molina S/. 50.00 Nuevos Soles; José espera el Giro de S/. 50.00 que su mamá le mando por el Banco de Crédito para poder hacer su viaje.

Se que es un problema casi común, pues iremos donde nuestra economía nos permita iremos, pero veamos bien José viajara por una de las opciones que tiene y como lo hará “Tomando una Decisión”; bien Viaja por la Empresa Ticllas o Expreso Molina, veamos esto en un código de C#:

1: if (jose == ticllas) 2: { 3: System.Console.WriteLine("Viajo en Ticllas"); 4: } 5: if (jose == exp_Molina) 6: { 7: System.Console.WriteLine("Viajo en Expreso Molina"); 8: }

Lo que se hace es Seleccionar una de las opciones pero ahora pongamos un concepto más técnico:

Una estructura selectiva se encarga de decidir bajo que condiciones se permite, o no se permite, la ejecución de una o varias sentencias de un algoritmo. De ahí que suele llamarse estructura de decisión o alternativa.

Si notamos en el Ejemplo anterior se podría dar que José viaje en los dos servicios pero eso no debería de pasar a poco no?

Entonces como solucionar:

1: if (jose == ticllas) 2: { 3: System.Console.WriteLine("Viajo en Ticllas"); 4: } 5: else 6: { 7: System.Console.WriteLine("Viajo en Expreso Molina"); 8: }

Sentencia If – Else(Si – De lo contrario)



En este tipo de sentencia se valida la primera opción y si no se cumple directamente se pasa a el código de contenido en else, viendo el ejemplo entonces si no viaja en Ticllas viajará en Expreso Molina.

Bueno ahora veamos un ejercicio un poco mas real:

Desarrolle una aplicación que imprima un mensaje si la persona es mayor de edad. (En Perú mayor de edad es a los 18 años)

Solución Básica.

1: namespace Ejemplos_MVA 2: { 3: class Program 4: { 5: static void Main(string[] args) 6: { 7: int edad = 0; 8: System.Console.WriteLine("Ingrese la edad: "); 9: edad = System.Convert.ToInt32(System.Console.ReadLine()); 10: if (edad >= 18) 11: { 12: System.Console.WriteLine("Es Mayor de Edad"); 13: } 14: else 15: { 16: System.Console.WriteLine("No es mayor de edad"); 17: } 18: } 19: } 20: 21: }

Solución Óptima.

1: namespace Ejemplos_MVA 2: { 3: class Program 4: { 5: static void Main(string[] args) 6: { 7: int edad = 0; 8: System.Console.WriteLine("Ingrese la edad: ");



9: edad = System.Convert.ToInt32(System.Console.ReadLine()); 10: if (edad >= 18) 11: { 12: System.Console.WriteLine("Es Mayor de Edad"); 13: } 14: else if (edad < 0) 15: { 16: System.Console.WriteLine("No existe esa edad"); 17: } 18: else 19: { 20: System.Console.WriteLine("No es mayor de edad"); 21: } 22: } 23: } 24: }

Ahora veamos otro ejemplo:

Desarrolle una aplicación que nos permita saber lo siguiente, según la edad que se haya ingresado:

• De 0 a 5 años –> Niñez • De 6 a 12 años –> Infancia • De 13 a 18 años –> Adolescencia • De 19 a 28 años –> Juventud • De 29 a 65 años -> Adultez • De 66 a más –> Adulto Mayor

1: namespace Ejemplos_MVA 2: { 3: class Program 4: { 5: static void Main(string[] args) 6: { 7: int edad = 0; 8: System.Console.WriteLine("Ingrese la edad: "); 9: edad = System.Convert.ToInt32(System.Console.ReadLine()); 10: if (edad >= 0 && edad<=5) 11: { 12: System.Console.WriteLine("Infancia");



13: } 14: else if (edad >= 6 && edad<=12) 15: { 16: System.Console.WriteLine("Niñez"); 17: } 18: else if (edad >= 13 && edad <= 18) 19: { 20: System.Console.WriteLine("Adolescencia"); 21: } 22: else if (edad >= 19 && edad <= 28) 23: { 24: System.Console.WriteLine("Juventud"); 25: } 26: else if (edad >= 29 && edad <= 65) 27: { 28: System.Console.WriteLine("Adultez"); 29: } 30: else if (edad >= 66) 31: { 32: System.Console.WriteLine("Adulto Mayor"); 33: } 34: System.Console.Read(); 35: } 36: } 37: }

Bien ahora hablemos de otro tipo de sentencia:

Switch – Case.

La instrucción switch es una instrucción de control que controla múltiples selecciones y enumeraciones pasando el control a una de las instrucciones case de su cuerpo, como se muestra en el ejemplo siguiente:

1: int caseSwitch = 1; 2: switch (caseSwitch) 3: { 4: case 1: 5: Console.WriteLine("Caso 1"); 6: break; 7: case 2: 8: Console.WriteLine("Caso 2"); 9: break;



10: default: 11: Console.WriteLine("Caso por Defecto"); 12: break; 13: }

Ahora veamos un ejemplo de este tipo de selección:

Desarrolle una aplicación que al ingresar un numero del 1 al 12, muestre su equivalente en los meses del año.

1: namespace Ejemplos_MVA 2: { 3: class Program 4: { 5: static void Main(string[] args) 6: { 7: int mes = 0; 8: System.Console.WriteLine("Ingrese el Mes: "); 9: mes = System.Convert.ToInt32(System.Console.ReadLine()); 10: switch (mes) 11: { 12: case 1: 13: System.Console.WriteLine("Enero"); 14: break; 15: case 2: 16: System.Console.WriteLine("Febrero"); 17: break; 18: case 3: 19: System.Console.WriteLine("Marzo"); 20: break; 21: case 4: 22: System.Console.WriteLine("Abril"); 23: break; 24: case 5: 25: System.Console.WriteLine("Mayo"); 26: break; 27: case 6: 28: System.Console.WriteLine("Junio"); 29: break; 30: case 7: 31: System.Console.WriteLine("Julio"); 32: break; 33: case 8: 34: System.Console.WriteLine("Agosto");



35: break; 36: case 9: 37: System.Console.WriteLine("Septiembre"); 38: break; 39: case 10: 40: System.Console.WriteLine("Octubre"); 41: break; 42: case 11: 43: System.Console.WriteLine("Noviembre"); 44: break; 45: case 12: 46: System.Console.WriteLine("Diciembre"); 47: break; 48: default: 49: System.Console.WriteLine("No haz ingresado un numero valido"); 50: break; 51: } 52: System.Console.Read(); 53: } 54: } 55: }

Como se dan cuenta en dentro de cada uno de los CASE hay una sentencia break, esta es la encargada de indicarle al momento de la consulta que ya no busque mas; es decir finalizar el Switch.

Por otro lado la sentencia DEFAULT es la encargada de realizar acciones cuando el dato ingresado no corresponda a ninguna de las opciones marcadas con el CASE.

Más Ejemplos de if-else.

Ejemplo 1 En este ejemplo, se escribe un carácter desde el teclado y el programa comprueba si se trata de un carácter alfabético. En ese caso, comprueba si es minúscula o mayúscula. En cada caso, se muestra el mensaje apropiado. // Sentencias_if_else.cs // if-else ejemplo using System;



class IfTest { static void Main() { Console.Write("Entre un caracter: "); char c = (char)Console.Read(); if (Char.IsLetter(c)) { if (Char.IsLower(c)) { Console.WriteLine("El caracter esta en minuscula."); } else { Console.WriteLine("El caracter esta en mayuscula."); } } else { Console.WriteLine("No es un caracter del alfabeto."); } } } Resultado. 2 Resultados del ejemplo Entre un caracter: 2 El caracter no es alfabético. A continuación se ofrece otro ejemplo: Ejecución Nº 2: Entre un caracter: A El caracter está en mayúscula. Ejecución Nº 3: Entre un caracter: h El carácter esta en minúscula. También es posible extender la instrucción if de modo que puedan controlarse varias condiciones, mediante la construcción else-if siguiente: if (Condicion_1) {



// Sentencia_1; } else if (Condicion_2) { // Sentencia_2; } else if (Condicion_3) { // Sentencia_3; } else { // Sentencia_n; } Ejemplo 2. Este ejemplo comprueba si el carácter especificado es una letra minúscula, mayúscula o un número. En cualquier otro caso, se tratará de un carácter no alfanumérico. El programa utiliza la anterior estructura else-if en escalera. // Sentencias_if_else2.cs // else-if using System; public class IfTest { static void Main() { Console.Write("Entre un caracter: "); char c = (char)Console.Read(); if (Char.IsUpper(c)) { Console.WriteLine("El caracter está en mayúscula."); } else if (Char.IsLower(c)) { Console.WriteLine("El caracter está en minúscula."); } else if (Char.IsDigit(c)) { Console.WriteLine("El caracter es un numero."); } else



{ Console.WriteLine("El caracter no es alfanumerico."); } } } Resultado E Resultados del ejemplo Entre un caracter: E El caracter esta en mayúscula. A continuación se ofrecen otros ejemplos de ejecuciones: Ejecución Nº 2: Entre un caracter: e El caracter está en minúscula. Ejecución Nº 3: Entre un caracter: 4 El caracter es un número. Ejecución Nº 4: Entre un caracter: $ El caracter no es alfanumerico.

1. Realizar un programa que lea por teclado dos números, si el primero es mayor al segundo informar su suma y diferencia, en caso contrario informar el producto y la división del primero respecto al segundo.

2. Se ingresan tres notas de un alumno, si el promedio es mayor o igual a siete mostrar un mensaje "Promocionado".

3. Se ingresa por teclado un número positivo de uno o dos dígitos (1..99) mostrar un mensaje indicando si el número tiene uno o dos dígitos. (Tener en cuenta que condición debe cumplirse para tener dos dígitos, un número entero)




IV. PROGRAMAR ESTRUCTURAS REPETITIVAS.


Definir una estructura repetitiva. Tipos de estructuras repetitivas en visual net. Elaborar casos prácticos utilizando estructuras repetitivas.





Definir una estructura repetitiva. Tipos de estructuras repetitivas en visual net. Elaborar casos prácticos utilizando estructuras repetitivas.

04



4.1. DEFINIR UNA ESTRUCTURA REPETITIVA:

Las estructuras de bucles de Visual Basic permiten ejecutar una o más líneas de código de forma repetitiva. Puede repetir las instrucciones de una estructura de bucles hasta que una condición sea True, una condición sea False, un número de veces especificado o una vez para cada objeto de una colección.

En el siguiente ejemplo se muestra una estructura de bucle que ejecuta un conjunto de instrucciones hasta que una condición se convierta en verdadera.

Ejecutar un conjunto de instrucciones hasta que una condición se convierta en verdadera

4.2. TIPOS DE ESTRUCTURAS REPETITIVAS EN VISUAL NET. Bucles While

La construcción While...End While ejecuta un conjunto de instrucciones mientras la condición especificada en la instrucción While sea True.

Bucles Do

La construcción Do...Loop le permite probar una condición al comienzo o al final de una estructura de bucle. También puede especificar si repite el bucle mientras la condición sigue siendo True o hasta que se convierta en True.

Bucles For

La construcción For...Next ejecuta el bucle un número fijo de veces. Utiliza una variable de control de bucle, también denominada contador para realizar el seguimiento de las repeticiones. Especifica los valores de inicio y fin de este



contador, y puede especificar opcionalmente la cantidad en la que se incrementa de una repetición a la siguiente.

Bucles For Each

La construcción For Each...Next ejecuta un conjunto de instrucciones una vez para cada elemento de una colección. Especifica la variable de control de bucle pero no tiene que determinar los valores de inicio y fin para ella.

4.3. ELABORAR CASOS PRÁCTICOS UTILIZANDO ESTRUCTURAS REPETITIVAS.

Usando while.

Escribir un programa que solicite la carga de un valor positivo y nos muestre desde 1 hasta el valor ingresado de uno en uno. Ejemplo: Si ingresamos 30 se debe mostrar en pantalla los números del 1 al 30.

Es de FUNDAMENTAL importancia analizar los diagramas de flujo y la posterior codificación en C# de los siguientes problemas, en varios problemas se presentan otras situaciones no vistas en el ejercicio anterior.

Diagrama de flujo:

Podemos observar que se ingresa por teclado la variable n. El operador puede cargar cualquier valor.



Si el operador carga 10 el bloque repetitivo se ejecutará 10 veces, ya que la condición es “Mientras x<=n ”, es decir “mientras x sea menor o igual a 10”; pues x comienza en uno y se incrementa en uno cada vez que se ejecuta el bloque repetitivo.

A la prueba del diagrama la podemos realizar dándole valores a las variables; por ejemplo, si ingresamos 5 el seguimiento es el siguiente:

n x 5 1 (Se imprime el contenido de x) 2 " " 3 " " 4 " " 5 " " 6 (Sale del while porque 6 no es menor o igual a 5)

Programa: using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraRepetitivaWhile2 { class Program { static void Main(string[] args) { int n,x; string linea; Console.Write("Ingrese el valor final:"); linea=Console.ReadLine(); n=int.Parse(linea); x=1; while (x<=n) { Console.Write(x); Console.Write(" - "); x = x + 1; } Console.ReadKey(); } } }



Los nombres de las variables n y x pueden ser palabras o letras (como en este caso)

La variable x recibe el nombre de CONTADOR. Un contador es un tipo especial de variable que se incrementa o decrementa con valores constantes durante la ejecución del programa.

El contador x nos indica en cada momento la cantidad de valores impresos en pantalla.

Ejemplo 1:

El usuario introduce números y el ordenador cuenta cuantos son positivos. class Program { static void Main(string[] args) { int positivos = 0; int conta = 0; int numero; Console.WriteLine("Introduce número "); numero = Int32.Parse(Console.ReadLine()); while (numero != 999) { conta = conta + 1; if (numero > 0) positivos = positivos + 1; Console.WriteLine("Introduce número "); numero = Int32.Parse(Console.ReadLine()); } Console.WriteLine("Has introducido un total de {0}", conta); Console.WriteLine("y son positivos {0}", positivos); } //fin Main

}

Ejemplo 2: Programa para poner notas: suspendido, aprobado, bien .. con la nota numérica. class Program { static void Main(string[] args) { double nota=0; string c_nota = "no asignada"; bool repetir = true; while (repetir == true)



{ try { Console.WriteLine("Introduce nota"); nota = Double.Parse(Console.ReadLine()); repetir = false; } catch (FormatException) { Console.Clear(); Console.WriteLine("Introducir sólo valores numéricos"); repetir = true; } } if (nota >0 && nota<10) { if (nota>=5) { if (nota>=6) { if (nota >= 7) { if (nota >= 9) c_nota = "sobresaliente"; else c_nota = "notable"; } else c_nota = "bien"; } else c_nota="aprobado"; } else c_nota ="suspendido"; } if (c_nota != "no asignada") { Console.WriteLine("La nota es de {0}", c_nota); } else Console.WriteLine("Nota no valida"); Console.WriteLine(); Console.WriteLine("Final del programa"); } // fi Main } // fin Class



Usando do while.

Ejemplo 01.

Escribir un programa que solicite la carga de un número entre 0 y 999, y nos muestre un mensaje de cuántos dígitos tiene el mismo. Finalizar el programa cuando se cargue el valor 0.

Diagrama de flujo:

No hay que confundir los rombos de las estructuras condicionales con los de las estructuras repetitivas do while.

En este problema por lo menos se carga un valor. Si se carga un valor mayor o igual a 100 se trata de un número de tres cifras, si es mayor o igual a 10 se trata de un valor de dos dígitos, en caso contrario se trata de un valor de un dígito. Este bloque se repite hasta que se ingresa en la variable valor el número 0 con lo que la condición de la estructura do while retorna falso y sale del bloque repetitivo finalizando el programa.

Programa:



using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace EstructuraRepetitivaDoWhile1

{

class Program

{

static void Main(string[] args)

{

int valor;

string linea;

do {

Console.Write("Ingrese un valor entre 0 y 999 (0 finaliza):");

linea = Console.ReadLine();

valor=int.Parse(linea);

if (valor>=100)

{

Console.WriteLine("Tiene 3 dígitos.");

}

else

{



if (valor>=10)

{

Console.WriteLine("Tiene 2 dígitos.");

}

else

{

Console.WriteLine("Tiene 1 dígito.");

}

}

} while (valor!=0);

}

}

}

Ejemplo 2:

Realizar un programa que pida una serie de números y al finalizar que saque el promedio de dichos números (0 para finalizar) using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraRepetitivaDoWhile { class Program { static void Main(string[] args) { int suma, cant, valor, promedio; string linea;



suma = 0; cant = 0; do { Console.Write("Ingrese un nimero (0 para finalizar):"); linea = Console.ReadLine(); valor = int.Parse(linea); if (valor != 0) { suma = suma + valor; cant++; } } while (valor != 0); if (cant != 0) { promedio = suma / cant; Console.Write("El promedio de los valores ingresados es:"); Console.Write(promedio); } else { Console.Write("No se ingresaron valores "); } Console.ReadLine(); } } } Al ejecutar el código muestra el siguiente resultado

Ejemplo 3:

En un banco se procesan datos de las cuentas corrientes de sus clientes. De cada cuenta corriente se conoce: número de cuenta y saldo actual. El ingreso de datos debe finalizar al ingresar un valor negativo en el número de cuenta.


http://3.bp.blogspot.com/-wtLl4IDd4dw/UeKgGXFcR3I/AAAAAAAABMI/pahmWHQZ-sc/s1600/estructura+repetitiva+do+while+solucion+1.png


Se pide realizar un programa que lea los datos de las cuentas corrientes e informe: a) De cada cuenta: número de cuenta y estado de la cuenta según su saldo, sabiendo que: Estado de la cuenta 'Acreedor' si el saldo es >0. 'Deudor' si el saldo es <0. 'Nulo' si el saldo es =0. b) La suma total de los saldos acreedores. using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraRepetitivaDoWhile { class Program { static void Main(string[] args) { int cuenta; float saldo, suma; string linea; suma = 0; do { Console.Write("Ingrese número de cuenta:"); linea = Console.ReadLine(); cuenta = int.Parse(linea); if (cuenta >= 0) { Console.Write("Ingrese saldo:"); linea = Console.ReadLine(); saldo = float.Parse(linea); if (saldo > 0) { Console.WriteLine("Saldo Acreedor."); suma = suma + saldo; } else { if (saldo < 0) {



Console.WriteLine("Saldo Deudor."); } else { Console.WriteLine("Saldo Nulo."); } } } } while (cuenta >= 0); Console.Write("Total de saldos Acreedores:"); Console.Write(suma); Console.ReadKey(); } } } Al ejecutar el código muestra el siguiente resultado

Usando for:

Ejemplo 1:

Realizar un programa que imprima en pantalla los números del 1 al 100.

Diagrama de flujo:


http://4.bp.blogspot.com/-IgeD6UtgrfQ/UeKihRxu_GI/AAAAAAAABMY/LE79rRLx04g/s1600/estructura+repetitiva+do+while+solucion+2.png


Podemos observar y comparar con el problema realizado con el while. Con la estructura while el CONTADOR x sirve para contar las vueltas. Con el for el CONTADOR f cumple dicha función.

Inicialmente f vale 1 y como no es superior a 100 se ejecuta el bloque, imprimimos el contenido de f, al finalizar el bloque repetitivo se incrementa la variable f en 1, como 2 no es superior a 100 se repite el bloque de instrucciones.

Cuando la variable del for llega a 101 sale de la estructura repetitiva y continúa la ejecución del algoritmo que se indica después del círculo.

La variable f (o como sea que se decida llamarla) debe estar definida como una variable más.

Programa:

using System;


using System.Linq;

using System.Text;

namespace EstructuraRepetitivaFor1

{

class Program

{


{

int f;

for(f=1;f<=100;f++)

{

Console.Write(f);

Console.Write("-");



}

Console.ReadKey();

}

}

}

Ejemplo 2:

Programa en el que el ordenador lanza 50 veces un dado y cuenta cuantas veces sale el nº 1.


{

int contador =0; int dado=0;

Random numero = new Random();

Console.Clear();

for (int t = 0; t<=50; t=t + 1)

{

dado = numero.Next(1, 7);

if (dado == 1)

{

contador = contador + 1;

Console.ForegroundColor = ConsoleColor.Red;

}

else Console.ForegroundColor = ConsoleColor.Gray;

Console.Write(" {0}", dado);

}



Console.WriteLine("-");

Console.WriteLine("Ha salido el número1 {0} veces",contador);

}

Ejemplo 3:

Programa que dibuja un Triangulo isósceles


{

Console.Clear();

// dibujo de cada linea (bucle externo)

for (int fila=1; fila <= 7; fila ++)

{

//dibuja espacios en blanco (1er bucle interno)

for (int espacios = 7 - fila; espacios > 0; espacios--)

Console.Write(" ");// espai en blanc

// dibuja estrellas (2º bucle interno)

for (int conta = 1; conta < (2 * fila); conta++)

Console.Write("*");

Console.WriteLine(" ");

}

}

Ejemplo 4:

Programa que muestra el día que será mañana. Ex: 31/12/08 -> 01/01/09

#include <iostream>



using namespace std;

int funcion_divisor(int numero, int divisor);

void main()

{

int d,max,m,a,resto;

printf("Introduce el dia: ");

scanf("%d",&d);

printf("\nIntroduce el mes: ");

scanf("%d",&m);

printf("\Introduce el anyo: ");

scanf("%d",&a);

printf("\nHoy es dia %d de %d del %d",d,m,a);

if (m==4 || m==6 || m==9 || m==11) max=30;

if (m==1 || m==3 || m==5 || m==7 || m==8 || m==10 || m==12) max=31;

if (m==2)

{

resto = funcion_divisor(a,4);

if (resto==0) max=29;

else max=28;

}

d++;

if (d>max)

{



d=1;

m++;

if (m>12) { m=1; a++; }

}

printf("\n\ny mañana será %d de %d del %d",d,m,a);

printf("\n\n");

}

int funcion_divisor(int numero, int divisor)

{

int resto = numero % divisor;

return (resto);

}

Ejemplo 5:

Programa para calcular Potencias, Tensiones e Intensidades. P = V * I

using System;


using System.Text;

class Ejercicio_2_6

{


{

string n_resultado="";

double resultado=0;



string teclado ="null";

while (teclado != "4")

{

Console.WriteLine("-");

Console.WriteLine("1-Poténcia 2-Tensión 3-Intensidad 4-Sortir");

teclado = Console.ReadLine();

switch (teclado)

{

case "1":

n_resultado = "Potencia";

resultado = fcalcul(n_resultado,"Tension","Intensitat"); break;

case "2":

n_resultado = "Tension";

resultado = fcalcul(n_resultado, "Potencia", "Intens."); break;

case "3":

n_resultado = "Intensidad";

resultado = fcalcul(n_resultado, "Potencia", "Tension"); break;

case "4":

break;

default: Console.WriteLine("Tecla equivocada") ; break;

}

Console.WriteLine("El resultado {0} es {1}", n_resultado, resultado);

}



} // fi Main

public static double fcalcul(string n_calculo, string nom1, string nom2)

{

Console.WriteLine("Introduce {0}",nom1);

string temp1 = Console.ReadLine();

int var1 = Int32.Parse(temp1);

Console.WriteLine("Introduce {0}", nom2);

string temp2 = Console.ReadLine();

int var2 = Int32.Parse(temp2);

if (n_calculo=="Potencia") return (var1 * var2);

else return (var1 / var2);

}

} //fi class Exercici6


TIPOS DE ESTRUCTURAS REPETITIVAS EN VISUAL NET.

DEFINIR UNA ESTRUCTURA REPETITIVA.

Sabemos hacer que el programa tome una serie de decisiones, en función del estado del programa. Y es hora de pasar al siguiente punto.

Un ordenador, como cualquier otro tipo de maquinaria, se basa en una repetición de instrucciones. Desde que el ordenador se enciende hasta que se apaga, estamos constantemente repitiendo instrucciones, con la única excepción de los datos que nosotros introducimos, los cuales cambian el resultado del proceso (variables).

Que un programa repita bloques de código es algo básico en cualquier programa. Pues no siempre vamos a hacer un programa “lineal” que cumpla



una rutina y salga. A veces nos interesará que, al finalizar, vuelva a comenzar. Y eso es exáctamente lo que vamos a aprender a hacer hoy.

Para empezar, con lo poco que sabemos, podemos hacer repeticiones básicas haciendo llamadas de funciones, dentro de funciones. Por ejemplo:

class Program

{

static int x = 0;

static void Programa()

{

x++;

Console.WriteLine("Repetición " + x.ToString() + "\n");

Console.ReadKey();

Programa();

}


{

Programa();

}

}

En éste ejemplo, al finalizar la función “Programa”, la última línea hace una llamada a la mísma función “Programa” en la que se encuentra. A ésto se le llama “Recursividad”, y sirve para crear bucles básicos.

Ésta forma de repetir código en C#, ni es la única, ni es la más eficiente. Así que, ademas de la recursividad, tenemos en nuestro repertorio una serie de clausulas que nos permitirán hacer bucles y repeticiones de código de forma más eficiente. La primera de ellas, es la clausula do.



En ésta clausula, repetiremos un fragmento de código, mientras se cumpla una condición. En el momento que no se cumpla, el bucle se rompe. Ejemplo práctico:


{

int x = 0;

do

{

Console.WriteLine(x.ToString() + "\n");

Console.ReadKey();

x++;

} while (x < 10);

Console.ReadKey();

}

En éste ejemplo, el código se repite siempre que se cumpla la condición de que X sea menor que 10. Es decir, cuenta de 0 a 9, y por último finaliza. La clausula do, viene siempre acompañada de un while al final, que indica la condición a cumplir.

Si en un momento dado queremos romper un bucle (lo cual se traduce, en salir de él y volver al código principal), podemos usar la palabra reservada break para ello.

do

{


Console.ReadKey();

x++;



if (x == 8) { break; }

} while (x < 10);

En éste caso, el programa sólo cuenta hasta 7, pues al llegar a 8 el bucle se rompe. La forma más eficiente sería indicar en While que sólo queremos contar hasta 8, pero es un ejemplo para ver su uso. Adiccionalmente, podemos usar la clausula while sin el do.

while (x < 10)

{

x++;


Console.ReadKey();

}

En caso de que lo que queramos, es saltarnos una repetición, podemos usar la palabra continue para ello. Ejemplo:

do

{

x++;

if (x == 8) { continue; }


Console.ReadKey();

} while (x < 10);

En éste caso, cuenta del 1 al 9, pero se salta el 8.

Otra forma de repetir código, es usando la clausula for. Generalmente usamos la clausula for para realizar una repetición durante un número determinado de repeticiones. Ejemplo:




{

for (int x = 0; x < 10; x++)

{


Console.ReadKey();

}

}

Éste ejemplo realiza la mísma función que el caso anterior, cuenta hasta 9 y, finalmente, el programa finaliza. También podemos usar la palabra break para finalizar el bucle en un punto dado. En éste caso, en la clausula for podemos declarar una variable (generalmente numérica), indicarle el límite, y la función que queremos realizar con dicha variable. Por ejemplo, podemos contar hacia adelante (x++), o hacer una cuenta regresiva (x–), o por qué no, contar de 2 en 2 (x+=2), o de 3 en 3 de forma regresiva (x-=3). En otras palabras, podemos indicarle cualquier función matemática que deseemos, incluso dividirlo (x=x/2). La cuestión es que el bucle no finalizará hasta que se cumpla la condición (en nuestro caso, que x sea menor que 10, x<10), o lo especifiquemos nosotros mediante un break.

Dentro del grupo de repeticiones, aún me queda una clausula, que es foreach. Pero ésta clausula está destinada a ser usada con matríces, y aún no he explicado nada sobre ello, así que lo dejaré para cuando lo haga.

Ahora bien. Las repeticiones son básicas y esenciales en cualquier programa, pero hay que tener mucho, mucho cuidado con su uso. Como ya he explicado, sólo finalizan cuando se cumpla una condición o se especifique con break. Pero, ¿Que pasaría si, por accidente, nuestra condición siempre fuese verdadera?


{

while (true)

{

Console.WriteLine("El programa está bloqueado");



}

}

En efecto, el programa se queda en un estado vulgarmente conocido como “bloqueado”, “pillado”, “colgado”, etc. En otras palabras, que no responde, pues se ha quedado procesando una instrucción constantemente y no puede salir del bucle.

En caso de que nuestro programa se bloquee por accidente (generalmente por un error en el programa), siempre podemos salír de él pulsando Ctrl+C (en el caso de la aplicación de consola).

Si estamos depurando, podemos también pulsar el botón “Detener depuración” (O Mayúsculas + F5) en nuestro entorno de desarrollo. En última instancia podemos usar el administrador de tareas (Alt+Ctrl+Supr), y cerrar el proceso manualmente.

Hay que tener mucho cuidado con ésto, sobre todo en programas muy complejos en los que se usen muchos bucles.

Es ideal diseñar el programa de forma que sea lo más simple posible, y su ejecución lo más límpia posible, y no llenarlo de bucles innecesarios, ya que puede surgir ésto, o incluso errores de desbordamiento en la pila de llamada (stack overflow). Pero en algunas ocasiones, sí nos interesa que el programa se repita indefinidamente.

Por ejemplo, para hacer un menú en un programa de consola, y que al introducir una opción y finalizar dicha tarea, vuelva al principio, mostrando el menú, hasta que el usuario introduzca la opción de salir, en cuyo caso usaremos un break para salir del bucle.



Hasta ahora hemos empleado estructuras SECUENCIALES y CONDICIONALES. Existe otro tipo de estructuras tan importantes como las anteriores que son las estructuras REPETITIVAS.

Una estructura repetitiva permite ejecutar una instrucción o un conjunto de instrucciones varias veces.

Una ejecución repetitiva de sentencias se caracteriza por: - La o las sentencias que se repiten.

- El test o prueba de condición antes de cada repetición, que motivará que se repitan o no las sentencias.

Estructura repetitiva while.

Representación gráfica de la estructura while:

No debemos confundir la representación gráfica de la estructura repetitiva while (Mientras) con la estructura condicional if (Si)

Funcionamiento: En primer lugar se verifica la condición, si la misma resulta verdadera se ejecutan las operaciones que indicamos por la rama del Verdadero. A la rama del verdadero la graficamos en la parte inferior de la condición. Una línea al final del bloque de repetición la conecta con la parte superior de la estructura repetitiva. En caso que la condición sea Falsa continúa por la rama del Falso y sale de la estructura repetitiva para continuar con la ejecución del algoritmo.

El bloque se repite MIENTRAS la condición sea Verdadera.



Importante: Si la condición siempre retorna verdadero estamos en presencia de un ciclo repetitivo infinito. Dicha situación es un error de programación, nunca finalizará el programa.

Estructura repetitiva do while.

La estructura do while es otra estructura repetitiva, la cual ejecuta al menos una vez su bloque repetitivo, a diferencia del while o del for que podían no ejecutar el bloque.

Esta estructura repetitiva se utiliza cuando conocemos de antemano que por lo menos una vez se ejecutará el bloque repetitivo.

La condición de la estructura está abajo del bloque a repetir, a diferencia del while o del for que está en la parte superior.


El bloque de operaciones se repite MIENTRAS que la condición sea Verdadera.

Si la condición retorna Falso el ciclo se detiene. En C#, todos los ciclos repiten por verdadero y cortan por falso.

Es importante analizar y ver que las operaciones se ejecutan como mínimo una vez.

Estructura repetitiva For.

Cualquier problema que requiera una estructura repetitiva se puede resolver empleando la estructura while. Pero hay otra estructura repetitiva cuyo planteo es más sencillo en ciertas situaciones.



En general, la estructura for se usa en aquellas situaciones en las cuales CONOCEMOS la cantidad de veces que queremos que se ejecute el bloque de instrucciones. Ejemplo: cargar 10 números, ingresar 5 notas de alumnos, etc. Conocemos de antemano la cantidad de veces que queremos que el bloque se repita. Veremos, sin embargo, que en el lenguaje C# la estructura for puede usarse en cualquier situación repetitiva, porque en última instancia no es otra cosa que una estructura while generalizada.


En su forma más típica y básica, esta estructura requiere una variable entera que cumple la función de un CONTADOR de vueltas. En la sección indicada como "inicialización contador", se suele colocar el nombre de la variable que hará de contador, asignándole a dicha variable un valor inicial. En la sección de "condición" se coloca la condición que deberá ser verdadera para que el ciclo continúe (en caso de un falso, el ciclo se detendrá). Y finalmente, en la sección de "incremento contador" se coloca una instrucción que permite modificar el valor de la variable que hace de contador (para permitir que alguna vez la condición sea falsa)

Cuando el ciclo comienza, antes de dar la primera vuelta, la variable del for toma el valor indicado en la sección de de "inicialización contador". Inmediatamente se verifica, en forma automática, si la condición es verdadera. En caso de serlo se ejecuta el bloque de operaciones del ciclo, y al finalizar el mismo se ejecuta la instrucción que se haya colocado en la tercer sección. Seguidamente, se vuelve a controlar el valor de la condición, y así prosigue hasta que dicha condición entregue un falso.

Si conocemos la cantidad de veces que se repite el bloque es muy sencillo emplear un for, por ejemplo si queremo que se repita 50 veces el bloque de instrucciones puede hacerse así:



La variable del for puede tener cualquier nombre. En este ejemplo se la ha definido con el nombre f.

Analicemos el ejemplo:

• La variable f toma inicialmente el valor 1. • Se controla automáticamente el valor de la condición: como f vale 1 y esto es

menor que 50, la condición da verdadero. • Como la condición fue verdadera, se ejecutan la/s operación/es. • Al finalizar de ejecutarlas, se retorna a la instrucción f++, por lo que la

variable f se incrementa en uno. • Se vuelve a controlar (automáticamente) si f es menor o igual a 50.

Como ahora su valor es 2, se ejecuta nuevamente el bloque de instrucciones e incrementa nuevamente la variable del for al terminar el mismo.

• El proceso se repetirá hasta que la variable f sea incrementada al valor 51. En este momento la condición será falsa, y el ciclo se detendrá.

La variable f PUEDE ser modificada dentro del bloque de operaciones del for, aunque esto podría causar problemas de lógica si el programador es inexperto. La variable f puede ser inicializada en cualquier valor y finalizar en cualquier valor. Además, no es obligatorio que la instrucción de modificación sea un incremento del tipo contador (f++).

Cualquier instrucción que modifique el valor de la variable es válida. Si por ejemplo se escribe f=f+2 en lugar de f++, el valor de f será incrementado de a 2 en cada vuelta, y no de a 1. En este caso, esto significará que el ciclo no efectuará las 50 vueltas sino sólo 25.



Estructura repetitiva Foreach.

La estructura foreach es en realidad azúcar sintáctica para trabajar con enumeraciones. Aunque no es objetivo de esta entrada hablar sobre las enumeraciones, recordaremos que una interfaz IEnumerable (que implementa cualquier colección, array, etc.) tiene un método: GetEnumerator, que nos regresa una interfaz IEnumerator.

Esta última interfaz tiene dos métodos y una propiedad: Current, que representa el objeto al que apunta el iterador, Reset, que mueve el apuntador del iterador al inicio de la colección, y MoveNext, que avanza en uno el apuntador del iterador. Así, para recorrer una colección, podríamos hacerlo con un bucle for, como vimos en la pregunta pasada:

string[] strs = GetStringArray(); IEnumerable enumerable = strs; IEnumerator e = enumberable.GetEnumerator(); for (e.Reset(); e.MoveNext(); ) { string str = e.Current as string; Console.WriteLine(str); }

Sin embargo, esto es un poco complejo, y C# pone a nuestra disposición los bucles foreach. Estos bucles se convierten en bucles for como el anterior, pero ocultan la complejidad. Por tanto, el bucle foreach sólo funcionará con colecciones que implementen IEnumerable. Básicamente declaramos una variable (equivalente al Current) y declaramos sobre qué colección se iterará. Internamente, el bucle foreach se hará cargo de llamar a Reset y MoveNext para saber dónde acaba la colección.

foreach (Tipo variable in colección) { }

El ejemplo anterior podríamos dejarlo como:

string[] strs = GetStringArray(); foreach (string str in strs) { Console.WriteLine(str); }

Mucho más fácil, ¿no?



Por supuesto, el foreach se adhiere a las reglas de IEnumerator. En particular, mientras se está iterando de esta forma, la colección no puede ser modificada. Si se modifica, tendremos una bonita excepción InvalidOperationException en nuestras manos.

List<string> strs = GetStringList(); foreach (string str in strs) { strs.Remove(str); // InvalidOperationException }

ELABORAR CASOS PRÁCTICOS UTILIZANDO ESTRUCTURAS REPETITIVAS.

Estructura repetitiva while.

Ejemplo 1:

Desarrollar un programa que permita la carga de 10 valores por teclado y nos muestre posteriormente la suma de los valores ingresados y su promedio.

Diagrama de flujo:

En este problema, a semejanza de los anteriores, llevamos un CONTADOR llamado x que nos sirve para contar las vueltas que debe repetir el while. También aparece el concepto de ACUMULADOR (un acumulador es un tipo especial de variable que se incrementa o decrementa con valores variables durante la ejecución del programa)

Hemos dado el nombre de suma a nuestro acumulador. Cada ciclo que se repita la estructura repetitiva, la variable suma se incrementa con el contenido ingresado en la variable valor.

La prueba del diagrama se realiza dándole valores a las variables:



valor suma x promedio 0 0 (Antes de entrar a la estructura repetitiva estos son los valores). 5 5 1 16 21 2 7 28 3 10 38 4 2 40 5 20 60 6 5 65 7 5 70 8 10 80 9 2 82 10 8 90 11

Este es un seguimiento del diagrama planteado. Los números que toma la variable valor dependerá de qué cifras cargue el operador durante la ejecución del programa.

El promedio se calcula al salir de la estructura repetitiva (es decir primero sumamos los 10 valores ingresados y luego los dividimos por 10)

Hay que tener en cuenta que cuando en la variable valor se carga el primer valor (en este ejemplo 5) al cargarse el segundo valor (16) el valor anterior 5 se pierde, por ello la necesidad de ir almacenando en la variable suma los valores ingresados.

Programa: using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraRepetitivaWhile3 { class Program { static void Main(string[] args) { int x,suma,valor,promedio; string linea; x=1; suma=0;



while (x<=10) { Console.Write("Ingrese un valor:"); linea = Console.ReadLine(); valor=int.Parse(linea); suma=suma+valor; x=x+1; } promedio=suma/10; Console.Write("La suma de los 10 valores es:"); Console.WriteLine(suma); Console.Write("El promedio es:"); Console.Write(promedio); Console.ReadKey(); } } }

Ejemplo 2: Una planta que fabrica perfiles de hierro posee un lote de n piezas. Confeccionar un programa que pida ingresar por teclado la cantidad de piezas a procesar y luego ingrese la longitud de cada perfil; sabiendo que la pieza cuya longitud esté comprendida en el rango de 1,20 y 1,30 son aptas. Imprimir por pantalla la cantidad de piezas aptas que hay en el lote. Diagrama de flujo:



Podemos observar que dentro de una estructura repetitiva puede haber estructuras condicionales (inclusive puede haber otras estructuras repetitivas que veremos más adelante)

En este problema hay que cargar inicialmente la cantidad de piezas a ingresar ( n ), seguidamente se cargan n valores de largos de piezas. Cada vez que ingresamos un largo de pieza (largo) verificamos si es una medida correcta (debe estar entre 1.20 y 1.30 el largo para que sea correcta), en caso de ser correcta la CONTAMOS (incrementamos la variable cantidad en 1)

Al contador cantidad lo inicializamos en cero porque inicialmente no se ha cargado ningún largo de medida.

Cuando salimos de la estructura repetitiva porque se han cargado n largos de piezas mostramos por pantalla el contador cantidad (que representa la cantidad de piezas aptas)

En este problema tenemos dos CONTADORES:

x (Cuenta la cantidad de piezas cargadas hasta el momento) cantidad (Cuenta los perfiles de hierro aptos)

Programa: using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraRepetitivaWhile4 { class Program { static void Main(string[] args) { int x,cantidad,n; float largo; string linea; x=1; cantidad=0; Console.Write("Cuantas piezar procesará:"); linea = Console.ReadLine(); n=int.Parse(linea);



while (x<=n) { Console.Write("Ingrese la medida de la pieza:"); linea = Console.ReadLine(); largo=float.Parse(linea); if (largo>=1.20 && largo<=1.30) { cantidad = cantidad +1; } x=x + 1; } Console.Write("La cantidad de piezas aptas son:"); Console.Write(cantidad); Console.ReadKey(); } } }

Ejemplo 3:

Realizar un programa que imprima en pantalla los números del 1 al 100. Sin conocer las estructuras repetitivas podemos resolver el problema empleando una estructura secuencial. Inicializamos una variable con el valor 1, luego imprimimos la variable, incrementamos nuevamente la variable y así sucesivamente. Diagrama de flujo:



Si continuamos con el diagrama no nos alcanzarían las próximas 5 páginas para finalizarlo. Emplear una estructura secuencial para resolver este problema produce un diagrama de flujo y un programa en C# muy largo. Ahora veamos la solución empleando una estructura repetitiva while:

Es muy importante analizar este diagrama: La primera operación inicializa la variable x en 1, seguidamente comienza la estructura repetitiva while y disponemos la siguiente condición ( x <= 100), se lee MIENTRAS la variable x sea menor o igual a 100. Al ejecutarse la condición retorna VERDADERO porque el contenido de x (1) es menor o igual a 100. Al ser la condición verdadera se ejecuta el bloque de instrucciones que contiene la estructura while. El bloque de instrucciones contiene una salida y una operación. Se imprime el contenido de x, y seguidamente se incrementa la variable x en uno. La operación x=x + 1 se lee como "en la variable x se guarda el contenido de x más 1". Es decir, si x contiene 1 luego de ejecutarse esta operación se almacenará en x un 2. Al finalizar el bloque de instrucciones que contiene la estructura repetitiva se verifica nuevamente la condición de la estructura repetitiva y se repite el proceso explicado anteriormente.



Mientras la condición retorne verdadero se ejecuta el bloque de instrucciones; al retornar falso la verificación de la condición se sale de la estructura repetitiva y continua el algoritmo, en este caso finaliza el programa. Lo más difícil es la definición de la condición de la estructura while y qué bloque de instrucciones se van a repetir. Observar que si, por ejemplo, disponemos la condición x >=100 ( si x es mayor o igual a 100) no provoca ningún error sintáctico pero estamos en presencia de un error lógico porque al evaluarse por primera vez la condición retorna falso y no se ejecuta el bloque de instrucciones que queríamos repetir 100 veces. No existe una RECETA para definir una condición de una estructura repetitiva, sino que se logra con una práctica continua solucionando problemas. Una vez planteado el diagrama debemos verificar si el mismo es una solución válida al problema (en este caso se debe imprimir los números del 1 al 100 en pantalla), para ello podemos hacer un seguimiento del flujo del diagrama y los valores que toman las variables a lo largo de la ejecución: x 1 2 3 4 . . 100 101 Cuando x vale 101 la condición de la estructura repetitiva retorna falso, en este caso finaliza el diagrama. Importante: Podemos observar que el bloque repetitivo puede no ejecutarse ninguna vez si la condición retorna falso la primera vez. La variable x debe estar inicializada con algún valor antes que se ejecute la operación x=x + 1 en caso de no estar inicializada aparece un error de compilación. Programa: using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraRepetitivaWhile1 { class Program {



static void Main(string[] args) { int x; x = 1; while (x <= 100) { Console.Write(x); Console.Write(" - "); x = x + 1; } Console.ReadKey(); } } } Recordemos que un problema no estará 100% solucionado si no hacemos el programa en C# que muestre los resultados buscados. Probemos algunas modificaciones de este programa y veamos que cambios se deberían hacer para: 1 - Imprimir los números del 1 al 500. 2 - Imprimir los números del 50 al 100. 3 - Imprimir los números del -50 al 0. Respuestas: 1 - Debemos cambiar la condición del while con x<=500. 2 - Debemos inicializar x con el valor 50. 3 - Inicializar x con el valor -50 y fijar la condición x<=0.

Estructura repetitiva do while.

Ejemplo 01:

Escribir un programa que solicite la carga de números por teclado, obtener su promedio. Finalizar la carga de valores cuando se cargue el valor 0. Cuando la finalización depende de algún valor ingresado por el operador conviene el empleo de la estructura do while, por lo menos se cargará un valor (en el caso más extremo se carga 0, que indica la finalización de la carga de valores)



Diagrama de flujo:

Es importante analizar este diagrama de flujo. Definimos un contador cant que cuenta la cantidad de valores ingresados por el operador (no lo incrementa si ingresamos 0) El valor 0 no es parte de la serie de valores que se deben sumar. Definimos el acumulador suma que almacena todos los valores ingresados por teclado. La estructura repetitiva do while se repite hasta que ingresamos el valor 0. Con dicho valor la condición del ciclo retorna falso y continúa con el flujo del diagrama. Disponemos por último una estructura condicional para el caso que el operador cargue únicamente un 0 y por lo tanto no podemos calcular el promedio ya que no existe la división por 0. En caso que el contador cant tenga un valor distinto a 0 el promedio se obtiene dividiendo el acumulador suma por el contador cant que tiene la cantidad de valores ingresados antes de introducir el 0.



Programa: using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraRepetitivaDoWhile2 { class Program { static void Main(string[] args) { int suma,cant,valor,promedio; string linea; suma=0; cant=0; do { Console.Write("Ingrese un valor (0 para finalizar):"); linea = Console.ReadLine(); valor=int.Parse(linea); if (valor!=0) { suma=suma+valor; cant++; } } while (valor!=0); if (cant!=0) { promedio=suma/cant; Console.Write("El promedio de los valores ingresados es:"); Console.Write(promedio); } else { Console.Write("No se ingresaron valores."); } Console.ReadLine(); } } } El contador cant DEBE inicializarse antes del ciclo, lo mismo que el acumulador suma. El promedio se calcula siempre y cuando el contador cant sea distinto a 0.

Ejemplo 2:

Realizar un programa que permita ingresar el peso (en kilogramos) de piezas. El proceso termina cuando ingresamos el valor 0. Se debe informar:



a) Cuántas piezas tienen un peso entre 9.8 Kg. y 10.2 Kg.?, cuántas con más de 10.2 Kg.? y cuántas con menos de 9.8 Kg.?

b) La cantidad total de piezas procesadas. Diagrama de flujo:

Los tres contadores cont1, cont2, y cont3 se inicializan en 0 antes de entrar a la estructura repetitiva. A la variable suma no se la inicializa en 0 porque no es un acumulador, sino que guarda la suma del contenido de las variables cont1, cont2 y cont3. La estructura se repite hasta que se ingresa el valor 0 en la variable peso. Este valor no se lo considera un peso menor a 9.8 Kg., sino que indica que ha finalizado la carga de valores por teclado. Programa:



using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraRepetitivaDoWhile3 { class Program { static void Main(string[] args) { int cant1,cant2,cant3,suma; float peso; string linea; cant1=0; cant2=0; cant3=0; do { Console.Write("Ingrese el peso de la pieza (0 pera finalizar):"); linea = Console.ReadLine(); peso=float.Parse(linea); if (peso>10.2) { cant1++; } else { if (peso>=9.8) { cant2++; } else { if (peso>0) { cant3++; } } } } while(peso!=0); suma=cant1+cant2+cant3; Console.Write("Piezas aptas:"); Console.WriteLine(cant2); Console.Write("Piezas con un peso superior a 10.2:");



Console.WriteLine(cant1); Console.Write("Piezas con un peso inferior a 9.8:"); Console.WriteLine(cant3); Console.ReadLine(); } } }

Estructura repetitiva For.

Ejemplo 01:

Desarrollar un programa que permita la carga de 10 valores por teclado y nos muestre posteriormente la suma de los valores ingresados y su promedio. Este problema ya lo desarrollamos, lo resolveremos empleando la estructura for. Diagrama de flujo:

En este caso, a la variable del for (f) sólo se la requiere para que se repita el bloque de instrucciones 10 veces. Programa: using System;



using System.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraRepetitivaFor2 { class Program { static void Main(string[] args) { int suma,f,valor,promedio; string linea; suma=0; for(f=1;f<=10;f++) { Console.Write("Ingrese valor:"); linea=Console.ReadLine(); valor=int.Parse(linea); suma=suma+valor; } Console.Write("La suma es:"); Console.WriteLine(suma); promedio=suma/10; Console.Write("El promedio es:"); Console.Write(promedio); Console.ReadKey(); } } } El problema requiere que se carguen 10 valores y se sumen los mismos. Tener en cuenta encerrar entre llaves bloque de instrucciones a repetir dentro del for. El promedio se calcula fuera del for luego de haber cargado los 10 valores. Ejemplo 2: Escribir un programa que lea 10 notas de alumnos y nos informe cuántos tienen notas mayores o iguales a 7 y cuántos menores. Para resolver este problema se requieren tres contadores: Aprobados (Cuenta la cantidad de alumnos aprobados) Reprobados (Cuenta la cantidad de reprobados) f (es el contador del for) Dentro de la estructura repetitiva debemos hacer la carga de la variable nota y verificar con una estructura condicional si el contenido de la variable nota es



mayor o igual a 7 para incrementar el contador aprobados, en caso de que la condición retorne falso debemos incrementar la variable reprobados. Diagrama de flujo:

Los contadores aprobados y reprobados deben imprimirse FUERA de la estructura repetitiva. Es fundamental inicializar los contadores aprobados y reprobados en cero antes de entrar a la estructura for. Importante: Un error común es inicializar los contadores dentro de la estructura repetitiva. En caso de hacer esto los contadores se fijan en cero en cada ciclo del for, por lo que al finalizar el for como máximo el contador puede tener el valor 1. Programa: using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraRepetitivaFor3 {



class Program { static void Main(string[] args) { int aprobados,reprobados,f,nota; string linea; aprobados=0; reprobados=0; for(f=1;f<=10;f++) { Console.Write("Ingrese la nota:"); linea = Console.ReadLine(); nota=int.Parse(linea); if (nota>=7) { aprobados=aprobados+1; } else { reprobados=reprobados+1; } } Console.Write("Cantidad de aprobados:"); Console.WriteLine(aprobados); Console.Write("Cantidad de reprobados:"); Console.Write(reprobados); Console.ReadKey(); } } } Ejemplo 3: Escribir un programa que lea 10 números enteros y luego muestre cuántos valores ingresados fueron múltiplos de 3 y cuántos de 5. Debemos tener en cuenta que hay números que son múltiplos de 3 y de 5 a la vez. Diagrama de flujo:



Tengamos en cuenta que el operador matemático % retorna el resto de dividir un valor por otro, en este caso: valor%3 retorna el resto de dividir el valor que ingresamos por teclado, por tres. Veamos: si ingresamos 6 el resto de dividirlo por 3 es 0, si ingresamos 12 el resto de dividirlo por 3 es 0. Generalizando: cuando el resto de dividir por 3 al valor que ingresamos por teclado es cero, se trata de un múltiplo de dicho valor. Ahora bien ¿por qué no hemos dispuesto una estructura if anidada? Porque hay valores que son múltiplos de 3 y de 5 a la vez. Por lo tanto con if anidados no podríamos analizar los dos casos.



Es importante darse cuenta cuando conviene emplear if anidados y cuando no debe emplearse. Programa: using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraRepetitivaFor4 { class Program { static void Main(string[] args) { int mul3,mul5,valor,f; string linea; mul3=0; mul5=0; for(f=1;f<=10;f++) { Console.Write("Ingrese un valor:"); linea = Console.ReadLine(); valor=int.Parse(linea); if (valor%3==0) { mul3=mul3+1; } if (valor%5==0) { mul5=mul5+1; } } Console.Write("Cantidad de valores ingresados múltiplos de 3:"); Console.WriteLine(mul3); Console.Write("Cantidad de valores ingresados múltiplos de 5:"); Console.Write(mul5); Console.ReadKey(); } } }



Ejemplo 4: Escribir un programa que lea n números enteros y calcule la cantidad de valores mayores o iguales a 1000. Este tipo de problemas también se puede resolver empleando la estructura repetitiva for. Lo primero que se hace es cargar una variable que indique la cantidad de valores a ingresar. Dicha variable se carga antes de entrar a la estructura repetitiva for. La estructura for permite que el valor inicial o final dependa de una variable cargada previamente por teclado. Diagrama de flujo:

Tenemos un contador llamado cantidad y f que es el contador del for. La variable entera n se carga previa al inicio del for, por lo que podemos fijar el valor final del for con la variable n. Por ejemplo si el operador carga 5 en n la estructura repetitiva for se ejecutará 5 veces. La variable valor se ingresa dentro de la estructura repetitiva, y se verifica si el valor de la misma es mayor o igual a 1000, en dicho caso se incrementa en uno el contador cantidad.



Fuera de la estructura repetitiva imprimimos el contador cantidad que tiene almacenado la cantidad de valores ingresados mayores o iguales a 1000. Programa: using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraRepetitivaFor5 { class Program { static void Main(string[] args) { int cantidad,n,f,valor; string linea; cantidad=0; Console.Write("Cuantos valores ingresará:"); linea = Console.ReadLine(); n=int.Parse(linea); for(f=1;f<=n;f++) { Console.Write("Ingrese el valor:"); linea = Console.ReadLine(); valor = int.Parse(linea); if (valor>=1000) { cantidad=cantidad+1; } } Console.Write("La cantidad de valores ingresados mayores o iguales a 1000 son:"); Console.Write(cantidad); Console.ReadKey(); } } }



1. Usando while o do while realizar los siguientes programas:

a) Realizar un programa que acumule (sume) valores ingresados por teclado hasta ingresar el 9999 (no sumar dicho valor, indica que ha finalizado la carga). Imprimir el valor acumulado e informar si dicho valor es cero, mayor a cero o menor a cero.

b) En un banco se procesan datos de las cuentas corrientes de sus clientes. De cada cuenta corriente se conoce: número de cuenta y saldo actual. El ingreso de datos debe finalizar al ingresar un valor negativo en el número de cuenta. Se pide confeccionar un programa que lea los datos de las cuentas corrientes e informe: - De cada cuenta: número de cuenta y estado de la cuenta según su saldo,

sabiendo que:

Estado de la cuenta 'Acreedor' si el saldo es >0. 'Deudor' si el saldo es <0. 'Nulo' si el saldo es =0.

- La suma total de los saldos acreedores.

2. Usando for realizar los siguien programas a) Desarrollar un programa que solicite la carga de 10 números e imprima la

suma de los últimos 5 valores ingresados. b) Desarrollar un programa que muestre la tabla de multiplicar del 5 (del 5 al

50). c) Confeccionar un programa que permita ingresar un valor del 1 al 10 y nos

muestre la tabla de multiplicar del mismo (los primeros 12 términos) Ejemplo: Si ingreso 3 deberá aparecer en pantalla los valores 3, 6, 9, hasta el 36.

d) Realizar un programa que lea los lados de n triángulos, e informar: - De cada uno de ellos, qué tipo de triángulo es: equilátero (tres lados iguales), isósceles (dos lados iguales), o escaleno (ningún lado igual). - Cantidad de triángulos de cada tipo. - Tipo de triángulo que posee menor cantidad.




V. PROGRAMAR ESTRUCTURAS ANIDADAS SIMPLES Y COMPLEJAS.


Definir la importancia de anidar correctamente dos o más estructuras. Desarrollar estructuras anidadas para la solución de problemas.





Definir la importancia de anidar correctamente dos o más estructuras. Desarrollar estructuras anidadas para la solución de problemas.

05



5.1. DEFINIR LA IMPORTANCIA DE ANIDAR CORRECTAMENTE DOS O MÁS ESTRUCTURAS.

Un ciclo anidado es un ciclo que contiene otro ciclo. En C tenemos 3 ciclos diferentes el ciclo while, do_while y for, estos ciclos se pueden anidar uno en otro ya sea el mismo ciclo o uno diferente. C permite 15 niveles de anidación, cuando se anida un ciclo dentro de otro siempre se terminan de realizar primero el ciclo que esta más anidado, por ejemplo en caso de que anidáramos dentro de un ciclo do while a un ciclo for, el ciclo for se terminaría primero.

Este programa lee las temperaturas de los 365 días del año cada hora

#include <conio.h>

#include <stdio.h>

void main(void)

{ float temp;

int dias=1, horas;

clrscr();

while(dias<=365)

{

for( horas=1;horas<=24;horas++)

{

printf(“Da la temperatura del día %d en la hora %d “,dias,horas);

scanf(“%f”,&temp);

}

dias=dias+1;

}

}



En este caso se pudieran utilizar 2 ciclos for, o 2 ciclos while, o 2 do_while, o la combinación de cualquiera de ellos, usted elige de acuerdo a lo que necesite que ciclos le conviene más utilizar.

Por ejemplo, tal vez para este programa usted hubiera elegido 2 ciclos for por ser más prácticos al estar controlados por contador.

#include <conio.h>

#include <stdio.h>

void main(void)

{ float temp;

int dias, horas;

clrscr();

for(dias=1;dias<=365;dias++)

for( horas=1;horas<=24;horas++)

{

printf(“Da la temperatura del día %d en la hora %d “,dias,horas);

scanf(“%f”,&temp);

}

}

5.2. DESARROLLAR ESTRUCTURAS ANIDADAS PARA LA SOLUCIÓN DE PROBLEMAS.

Confeccionar un programa que pida por teclado tres notas de un alumno, calcule el promedio e imprima alguno de estos mensajes: Si el promedio es >=7 mostrar "Promocionado". Si el promedio es >=4 y <7 mostrar "Regular". Si el promedio es <4 mostrar "Reprobado".

Diagrama de flujo:



Analicemos el siguiente diagrama. Se ingresan tres valores por teclado que representan las notas de un alumno, se obtiene el promedio sumando los tres valores y dividiendo por 3 dicho resultado (Tener en cuenta que si el resultado es un valor real solo se almacena la parte entera).

Primeramente preguntamos si el promedio es superior o igual a 7, en caso afirmativo va por la rama del verdadero de la estructura condicional mostramos un mensaje que indica "Promocionado" (con comillas indicamos un texto que debe imprimirse en pantalla).

En caso que la condición nos de falso, por la rama del falso aparece otra estructura condicional, porque todavía debemos averiguar si el promedio del alumno es superior o igual a cuatro o inferior a cuatro.

Estamos en presencia de dos estructuras condicionales compuestas.

Programa: import java.util.Scanner; public class EstructuraCondicionalAnidada1 { public static void main(String[] ar) { Scanner teclado=new Scanner(System.in); int nota1,nota2,nota3; System.out.print("Ingrese primer nota:"); nota1=teclado.nextInt();



System.out.print("Ingrese segunda nota:"); nota2=teclado.nextInt(); System.out.print("Ingrese tercer nota:"); nota3=teclado.nextInt(); int promedio=(nota1 + nota2 + nota3) / 3; if (promedio>=7) { System.out.print("Promocionado"); } else { if (promedio>=4) { System.out.print("Regular"); } else { System.out.print("Reprobado"); } } } } Codifiquemos y ejecutemos este programa. Al correr el programa deberá solicitar por teclado la carga de tres notas y mostrarnos un mensaje según el promedio de las mismas. Podemos definir un conjunto de variables del mismo tipo en una misma línea: int nota1,nota2,nota3; Esto no es obligatorio pero a veces, por estar relacionadas, conviene. A la codificación del if anidado podemos observarla por el else del primer if. Para no tener problemas (olvidarnos) con las llaves de apertura y cerrado podemos ver la siguiente regla: Cada vértice representa una llave de apertura y una de cierre:



FUNDAMENTO TEÓRICO:

Definir la importancia de anidar correctamente dos o más estructuras.

El anidamiento (llamado nesting en inglés) es la práctica de incorporar llamadas (calls) a funciones o procedimientos (unas) dentro de otras, mediante la inclusión de diversos niveles de paréntesis. Debido a que la potencial acumulación de éstos últimos suele hacer que la edición y la detección de errores se vuelva un proceso engorroso, los entornos de programación modernos -así como los programas de planilla de cálculo- resaltan en negrita el par correspondiente a la posición que está editando el programador o usuario en cada momento. El control (automático) del balance o equilibrio entre los paréntesis de apertura y de cierre se suele conocer como brace match checking en inglés. Naturalmente, para la resolución matemática de estas complejas formulas encadenadas, las expresiones deben ser evaluadas desde adentro hacia afuera, ya que los resultados de las más internas sirven, temporalmente, de datos de entrada de las exteriores. En las planillas de cálculo.

En las hojas de cálculo, se suelen anidar o agrupar funciones unas dentro de otras, derivando en fórmulas relativamente complejas. El programa OpenOffice.org Calc permite, mediante su asistente de funciones (function wizard), navegar a través de los varios o múltiples niveles de anidamiento, permitiendo editar (y eventualmente corregir) cada una de ellas por separado. Tal vez de manera sorprendente, su rival Microsoft Excel no posee esa característica, eventualmente deseable cuando se trabaja en algunas grandes planillas. En programación.

En los lenguajes de programación estructurada, el anidamiento está relacionado a la inclusión de estructuras de control dentro de otras, usualmente indicado mediante la inclusión de distintos niveles de sangría (llamada indentation en inglés) dentro del código fuente, como se muestra en el sencillo código BASIC siguiente:

function BuscarCodigo(cod as string) as integer dim linea, ruta as string dim valor_a_devolver as integer


http://es.wikipedia.org/wiki/Idioma_ingl%C3%A9s

http://es.wikipedia.org/wiki/Funci%C3%B3n_%28programaci%C3%B3n%29

http://es.wikipedia.org/wiki/Procedimiento_%28Programaci%C3%B3n%29

http://es.wikipedia.org/wiki/Hoja_de_c%C3%A1lculo

http://es.wikipedia.org/wiki/OpenOffice.org

http://es.wikipedia.org/wiki/OpenOffice.org_Calc

http://es.wikipedia.org/wiki/Microsoft_Excel

http://es.wikipedia.org/wiki/Lenguaje_de_programaci%C3%B3n

http://es.wikipedia.org/wiki/Programaci%C3%B3n_estructurada

http://es.wikipedia.org/wiki/Estructuras_de_control

http://es.wikipedia.org/wiki/C%C3%B3digo_fuente

http://es.wikipedia.org/wiki/BASIC


ruta="C:\Probar.csv" if FileExists(ruta) then open "C:\Probar.csv" for input as #1 do while not EOF(1) line input #1, linea if left(linea, 3)=cod then 'Realizar una acción o varias acciones End if loop close #1 BuscarCodigo=valor_a_devolver end function

En este simple ejemplo, la estructura condicional if... then... end if ("si... entonces... fin si") está anidada dentro de otra que la contiene, el ciclo do while... loop ("repetir... mientras", literalmente "hacer mientras... bucle").

El anidamiento Cualquier instrucción puede ser sustituida por una estructura de control. El siguiente ejemplo muestra el pseudocódigo del ordenamiento de burbuja, que tiene varias estructuras anidadas. Este algoritmo ordena de menor a mayor los elementos de una lista .

En general, las estructuras anidadas se muestran indentadas, para hacer más sencilla su identificación a simple vista. En el ejemplo, además de la indentación, se ha conectado con flechas los pares de delimitadores de cada nivel de anidamiento.


http://es.wikipedia.org/wiki/Bucle_%28programaci%C3%B3n%29

http://es.wikipedia.org/wiki/Ordenamiento_de_burbuja


DESARROLLAR ESTRUCTURAS ANIDADAS PARA LA SOLUCIÓN DE PROBLEMAS.

Puede colocar instrucciones de control dentro de otras instrucciones de control, por ejemplo un bloque If...Then...Else dentro de un bucle For...Next. Cuando una instrucción de control se coloca dentro de otra, se dice que está anidada.

• Niveles de anidamiento.

En Visual Basic, las instrucciones de control pueden anidarse en tantos niveles como se desee. A fin de que las estructuras anidadas sean más fáciles de leer, es práctica habitual aplicar sangría al cuerpo de cada una. El editor del entorno de desarrollo integrado (IDE) lo hace automáticamente.

En el siguiente ejemplo, el procedimiento sumRows suma los elementos positivos de cada fila de la matriz.

Public Sub sumRows(ByVal a(,) As Double, ByRef r() As Double) Dim i, j As Integer For i = 0 To UBound(a, 1) r(i) = 0 For j = 0 To UBound(a, 2) If a(i, j) > 0 Then r(i) = r(i) + a(i, j) End If Next j Next i End Sub

En el ejemplo anterior, la primera instrucción Next cierra el bucle For interno y la última instrucción Next cierra el bucle For externo.

Del mismo modo, en las instrucciones If anidadas, las instrucciones End If se aplican automáticamente a la instrucción If anterior más próxima. Los bucles Do anidados funcionan de forma similar; la instrucción Loop más interna está emparejada con la instrucción Do más interna.

• Anidar diferentes tipos de estructuras de control.

Puede anidar un tipo de estructura de control dentro de otro tipo. El ejemplo siguiente utiliza un bloque With dentro de un bucle For Each y bloques If anidados dentro del bloque With.

For Each ctl As System.Windows.Forms.Control In Me.Controls With ctl



.BackColor = System.Drawing.Color.Yellow .ForeColor = System.Drawing.Color.Black If .CanFocus Then .Text = "Colors changed" If Not .Focus() Then ' Insert code to process failed focus. End If End If End With Next ctl • Superposición de estructuras de control.

No puede superponer estructuras de control. Esto significa que cualquier estructura anidada debe estar completamente incluida dentro de la siguiente estructura más profunda. Por ejemplo, la organización siguiente no es válida porque el bucle For finaliza antes de que termine el bloque With interno.

Anidamiento no válido de estructuras For y With



1. Crea una aplicación que dibuje una escalera de asteriscos. Nosotros le pasamos la altura de la escalera por teclado. Este es un ejemplo si insertaras un 5 de altura:

2. Crea una aplicación que dibuje una pirámide volteada de asteriscos.

Nosotros le pasamos la altura de la pirámide por teclado. Este es un ejemplo, si introducimos 5 de altura:

3. Crea una aplicación que dibuje una escalera de números, siendo cada linea números empezando en uno y acabando en el numero de la linea. Este es un ejemplo, si introducimos un 5 como altura:



http://www.discoduroderoer.es/wp-content/uploads/2013/07/escalera.png

http://www.discoduroderoer.es/wp-content/uploads/2013/07/piramide.png

http://www.discoduroderoer.es/wp-content/uploads/2013/07/escalera-de-numero.png


VI. ELABORAR PROCEDIMIENTOS PARA RESOLVER CASOS PRÁCTICOS.


Identificar la importancia de un procedimiento. Programar procedimientos para resolver casos prácticos.





Identificar la importancia de un procedimiento. Programar procedimientos para resolver casos prácticos.

06



6.1. IDENTIFICAR LA IMPORTANCIA DE UN PROCEDIMIENTO.

(procedure). En programación, un tipo de subrutina.

Porción de código dentro de un programa más grande, que realiza una tarea específica y es relativamente independiente del resto del código. La mayoría de los lenguajes de programación incluyen soporte para la creación de procedimientos (u otros tipos de subrutinas, como funciones o módulos). Los procedimientos suelen utilizarse para reducir la duplicación de códigos en un programa, permitir reusar los códigos, descomponer problemas complejos en piezas simples (mejorando la mantenibilidad y facilidad de extensión del código), mejora la lectura del código de un programa, oculta o regula parte de un programa, etc.

Los procedimientos son ejecutados cuando son llamados desde otros procedimientos, funciones o módulos. Los procedimientos pueden recibir parámetros, pero no necesitan devolver un valor como las funciones. Cada lenguaje de programación tiene su propia implementación de procedimientos (si es que posee procedimientos).

Ejemplo

A modo de ejemplo, si queremos mostrar el anterior, el posterior y un propio número de una lista (vector), un pseudocódigo por procedimientos o funciones (a alto nivel) sería:

funcion a_p( numero ) { out(numero-1); out(numero); out(numero+1); } for( i = 0; i < tamaño(lista); i++){ a_p( lista[i] ); }

O si queremos dividir al número por 2,3,4,5,6,7,8,9 y 10 en otro pseudocódigo:

funcion div(numero) { out(numero/2); out(numero/3);


http://www.alegsa.com.ar/Dic/programacion.php

http://www.alegsa.com.ar/Dic/lenguaje%20de%20programacion.php

http://www.alegsa.com.ar/Dic/funcion.php

http://www.alegsa.com.ar/Dic/modulo.php

http://www.alegsa.com.ar/Dic/parametro.php

http://es.wikipedia.org/wiki/Vector

http://es.wikipedia.org/wiki/Pseudoc%C3%B3digo

http://es.wikipedia.org/wiki/Pseudoc%C3%B3digo


out(numero/4); out(numero/5); out(numero/6); out(numero/7); out(numero/8); out(numero/9); out(numero/10); } for( i = 0; i < tamaño(lista); i++){ div( lista[i] ); }

Utilizar este tipo de programación puede resultar muy útil a la hora de programar grandes proyectos, ya que se crea una inmensa biblioteca de funciones especiales para procedimientos utilizados con frecuencia dentro del programa.

Por contrapartida, es muy difícil determinar cuál es el número mínimo de instrucciones consecutivas, y el mínimo número que esta secuencia se debe repetir para considerar declarar un procedimiento o una función.

6.2. PROGRAMAR PROCEDIMIENTOS PARA RESOLVER CASOS PRÁCTICOS.

Ejemplo 1:

Realizar un programa para la cracion de una agenda

Código:

using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace Clases { public class Agenda { float version = 1.0f; // variable privada



// no puede salir de la clase // solo puede ser usada // dentro de la clase public string Nombre; // poniendo "public" delante // de cualquier funcion // o variable, habilitamos // su uso al invocar la clase private int Sexo; public void DameTuNombre() { if (Version() == 1.0f) { Console.WriteLine("Cual es tu nombre?"); Nombre = Console.ReadLine(); } } // podemos sobrecargar una función // en otras palabras, crear la misma // función con diferentes argumentos public void DameTuNombre(string nombre) { Nombre = nombre; } public string DameTu(string algo) { Console.WriteLine("Escribe tu {0,0:s}", algo); Nombre = Console.ReadLine(); return Nombre; } private float Version() { return version; } // como ves, no es nada del otro mundo // luego hay más historias, cómo el tema // de los punteros en C#, el "delegate" // la herencia, y esas cosillas..ZZzzz } class Program { static void Main(string[] args)



{ int numero = 3; string cadena = "mi cadena"; Agenda A = new Agenda (); A.Nombre = "Pedro"; A.DameTuNombre(); A.DameTuNombre("Pepito"); cadena=A.DameTu("el nombre de tu abuela"); Console.WriteLine("Hola {0,0:s}! ah! y tú también Mundo...jajaj" ,cadena); Console.ReadLine(); } } }

Ejemplo 2:

Mini-Calculadora en modo consola

1. using System; 2. 3. namespace Calculadora 4. { 5. class Program 6. { 7. public static void Main(string[] args) 8. { 9. float primero; // El primer número 10. float segundo; // El segundo número 11. string operacion; // La operación a realizar 12. 13. Console.Title = "Mini-Calculadora"; // Damos

formato a la consola 14. Console.BackgroundColor =

ConsoleColor.White; 15. Console.ForegroundColor =

ConsoleColor.Blue;



16. Console.Clear(); 17. 18. Console.SetCursorPosition (3,2); // Pedimos

el primer número 19. Console.WriteLine ("Introduzca el

primer número"); 20. Console.SetCursorPosition (60,2); 21. primero = float.Parse(Console.ReadLine()); 22. 23. Console.SetCursorPosition (3,3); // Pedimos

la operación 24. Console.WriteLine ("Introduzca la operación

a realizar (+,-,*,/)"); 25. Console.SetCursorPosition (59,3); 26. operacion = Console.ReadLine(); 27. 28. Console.SetCursorPosition (3,4); // Pedimos

el segundo número 29. Console.WriteLine ("Introduzca el segundo

número"); 30. Console.SetCursorPosition (60,4); 31. segundo = float.Parse(Console.ReadLine()); 32. 33. 34. Console.SetCursorPosition (57,5); //

Mostramos la solucion... 35. Console.WriteLine ("__________"); 36. 37. Console.SetCursorPosition (3,6); 38. Console.WriteLine ("El resultado es"); 39. Console.SetCursorPosition (60,6); 40. 41. Console.WriteLine

(calcular(primero,segundo,operacion)); 42. Console.ReadKey (); 43. 44. } 45. 46. private static string calcular (float primero , float segundo,

string operacion) 47. { 48. float temp; 49. switch (operacion) // Estructura con switch 50. {



51. case "+": 52. temp = primero + segundo; 53. return temp.ToString (); 54. case "-": 55. temp = primero - segundo; 56. return temp.ToString (); 57. case "*": 58. temp = primero * segundo; 59. return temp.ToString (); 60. case "/": 61. temp = primero / segundo; 62. return temp.ToString (); 63. } 64. return "-1"; 65. } 66. } 67. } 68.

Mini-Calculadora en modo gráfico: (los nombres de los controles son faciles de deducir viendo el code ) Código

1. using System; 2. using System.Collections.Generic; 3. using System.Drawing; 4. using System.Windows.Forms; 5. using System.Text; 6. 7. namespace Calculadora 8. { 9. /// <summary> 10. /// Description of MainForm. 11. /// </summary> 12. public partial class MainForm : Form 13. { 14. int oper ; // 1 -> + | 2 -> - | 3 -> * | 4 -> / 15. float primero; 16. 17. 18. public MainForm() 19. { 20. InitializeComponent();



21. } 22. 23. void Numero7Click(object sender, EventArgs e) 24. { 25. txtnum.Text = txtnum.Text + 7; 26. } 27. 28. void Numero8Click(object sender, EventArgs e) 29. { 30. txtnum.Text = txtnum.Text + 8; 31. } 32. 33. void Numero9Click(object sender, EventArgs e) 34. { 35. txtnum.Text = txtnum.Text + 9; 36. } 37. 38. void Numero4Click(object sender, EventArgs e) 39. { 40. txtnum.Text = txtnum.Text + 4; 41. } 42. 43. void Numero5Click(object sender, EventArgs e) 44. { 45. txtnum.Text = txtnum.Text + 5; 46. } 47. 48. void Numero6Click(object sender, EventArgs e) 49. { 50. txtnum.Text = txtnum.Text + 6; 51. } 52. 53. void Numero1Click(object sender, EventArgs e) 54. { 55. txtnum.Text = txtnum.Text + 1; 56. } 57. 58. void Numero2Click(object sender, EventArgs e) 59. { 60. txtnum.Text = txtnum.Text + 2; 61. } 62. 63. void Numero3Click(object sender, EventArgs e) 64. {



65. txtnum.Text = txtnum.Text + 3; 66. } 67. 68. void Numero0Click(object sender, EventArgs e) 69. { 70. txtnum.Text = txtnum.Text + 0; 71. } 72. 73. void CClick(object sender, EventArgs e) 74. { 75. txtnum.Text = ""; 76. } 77. 78. void DivClick(object sender, EventArgs e) 79. { 80. oper = 4; 81. primero = float.Parse (txtnum.Text); 82. txtnum.Text = ""; 83. } 84. 85. void MulClick(object sender, EventArgs e) 86. { 87. oper = 3; 88. primero = float.Parse (txtnum.Text); 89. txtnum.Text = ""; 90. } 91. 92. void ResClick(object sender, EventArgs e) 93. { 94. oper = 2; 95. primero = float.Parse (txtnum.Text); 96. txtnum.Text = ""; 97. } 98. 99. void SumClick(object sender, EventArgs e) 100. { 101. oper = 1; 102. primero = float.Parse (txtnum.Text); 103. txtnum.Text = ""; 104. } 105. 106. void SolClick(object sender, EventArgs e) 107. { 108. float segundo = int.Parse (txtnum.Text);



109. float resultado; 110. 111. switch (oper) 112. { 113. case 1: 114. resultado = primero + segundo; 115. txtnum.Text = resultado.ToString(); 116. break; 117. case 2: 118. resultado = primero - segundo; 119. txtnum.Text = resultado.ToString(); 120. break; 121. case 3: 122. resultado = primero * segundo; 123. txtnum.Text = resultado.ToString(); 124. break; 125. case 4: 126. resultado = primero / segundo; 127. txtnum.Text = resultado.ToString(); 128. break; 129. } 130. } 131. } 132. }

Ejemplo 3:

Resolver ecuaciones de seegundo grado (añadir 3 text box y un boton)

1. using System; 2. using System.Collections.Generic; 3. using System.ComponentModel; 4. using System.Data; 5. using System.Drawing; 6. using System.Text; 7. using System.Windows.Forms; 8. 9. namespace Ecuaciones 10. { 11. public partial class Form1 : Form 12. { 13. public Form1() 14. {



15. InitializeComponent(); 16. } 17. 18. private void resolver_Click(object sender, EventArgs e) 19. { 20. ecuacion miEcuacion = new ecuacion (double.Parse(a.Text),

double.Parse(b.Text), double.Parse(c.Text)); 21. } 22. } 23. }

Ejemplo 4:

Exporador de carpetas: (añadir un text box "txtRuta" dos listas "lbcar" y "lbar" y un boton con nombre por defecto)

1. using System; 2. using System.Collections.Generic; 3. using System.ComponentModel; 4. using System.Data; 5. using System.Drawing; 6. using System.Text; 7. using System.Windows.Forms; 8. using System.IO; 9. 10. namespace ExploradorCarpetas 11. { 12. public partial class Form1 : Form 13. { 14. public Form1() 15. { 16. InitializeComponent(); 17. } 18. 19. // El form load 20. private void Form1_Load(object sender, EventArgs e) 21. { 22. // Iniciamos el txtRuta 23. txtRuta.Text=Directory.GetDirectoryRoot(Directory.GetCurrentDirectory(

)); 24. 25. // Listamos las carpetas


http://www.google.com/search?q=new+msdn.microsoft.com


26. carpetas(txtRuta.Text); 27. 28. // Listamos los archivos 29. archivos(txtRuta.Text); 30. } 31. 32. // El botón para explorar rutas 33. private void button1_Click(object sender, EventArgs e) 34. { 35. // Listamos las carpetas 36. carpetas(txtRuta.Text); 37. 38. // Listamos los archivos 39. archivos(txtRuta.Text); 40. } 41. 42. // Al hacer doble click sobre una ruta la colocamos en txtRuta 43. private void lbcar_DoubleClick(object sender, EventArgs e) 44. { 45. txtRuta.Text = lbcar.SelectedItem.ToString(); 46. 47. // Listamos las carpetas 48. carpetas(txtRuta.Text); 49. 50. // Listamos los archivos 51. archivos(txtRuta.Text); 52. } 53. 54. // Metodo que coloca las carpetas de la ruta indicada en el list 55. // box correspondiente 56. private void carpetas(string ruta) 57. { 58. lbcar.Items.Clear(); 59. 60. string[] carpeta = Directory.GetDirectories(ruta); 61. 62. foreach(string car in carpeta) 63. lbcar.Items.Add (car); 64. } 65. 66. // Metodo que coloca los archivos de la ruta indicada en el list 67. // box correspondiente 68. private void archivos(string ruta) 69. {



70. lbar.Items.Clear(); 71. 72. string[] archivo = Directory.GetFiles(ruta); 73. 74. foreach (string ar in archivo) 75. lbar.Items.Add(ar); 76. } 77. } 78. }

Ejemplo 5:

Operaciones simples con matrices:

1. using System; 2. 3. namespace Matrices 4. { 5. class Program 6. { 7. public static void Main(string[] args) 8. { 9. float [,] mat1; // Las matrices 10. float [,] mat2; 11. 12. int f1, c1; // El número de filas y columnas de las matrices 13. int f2, c2; 14. 15. //Llamamos al menu y recojemos la opción seleccionada 16. byte opcion; 17. do { 18. opcion = menu(); 19. } while (opcion >= 5); 20. 21. switch (opcion) 22. { 23. case 1: // SUMA 24. 25. // Leemos el número de filas y columnas de las matrices 1 y 2 26. Console.WriteLine ("Introduzca el número de

filas de las matrices 1 y 2"); 27. f1 = int.Parse (Console.ReadLine());



28. Console.WriteLine ("Introduzca el número de columnas de las matrices 1 y 2");

29. c1 = int.Parse (Console.ReadLine());

30. 31. // Pedimos los datos de filas y

columnas 32. Console.WriteLine ("Introduzca los

datos de la matriz 1 enumerandolos por filas:"); 33. mat1 = leer(f1,c1); 34. Console.WriteLine ("Introduzca los

datos de la matriz 2 enumerandolos por filas:"); 35. mat2 = leer(f1,c1); 36. 37. //Mostramos la suma de ambas

matrices 38. suma(mat1,mat2); 39. break; 40. 41. case 2: // RESTA 42. 43. // Leemos el número de filas y

columnas de las matrices 1 y 2 44. Console.WriteLine ("Introduzca el

número de filas de las matrices 1 y 2"); 45. f1 = int.Parse (Console.ReadLine()); 46. Console.WriteLine ("Introduzca el

número de columnas de las matrices 1 y 2"); 47. c1 = int.Parse

(Console.ReadLine()); 48. 49. 50. // Pedimos los datos de filas y


datos de la matriz 1 enumerandolos por filas:"); 52. mat1 = leer(f1,c1); 53. Console.WriteLine ("Introduzca los

datos de la matriz 2 enumerandolos por filas:"); 54. mat2 = leer(f1,c1); 55. 56. // Mostramos la resta de ambas

matrices 57. resta (mat1, mat2);



58. break; 59. 60. case 3: // PRODUCTO POR UN ESCALAR 61. 62. // Leemos el número de filas y

columnas de la matriz 1 63. Console.WriteLine ("Introduzca el

número de filas de la matriz 1"); 64. f1 = int.Parse (Console.ReadLine()); 65. Console.WriteLine ("Introduzca el

número de columnas de la matriz 1"); 66. c1 = int.Parse

(Console.ReadLine()); 67. 68. float escalar; 69. Console.WriteLine ("Introduzca el

escalar por el que quiere multiplicar la matriz"); 70. escalar =

float.Parse(Console.ReadLine()); 71. 72. // Pedimos los datos de filas y


datos de la matriz 1 enumerandolos por filas:"); 74. mat1 = leer(f1,c1); 75. 76. // Mostramos la solución 77. prodEscalar (mat1,escalar); 78. 79. break; 80. } 81. Console.ReadKey(); 82. } 83. 84. // Función que muestra el menu de selección de operaciones 85. public static byte menu() 86. { 87. try { 88. byte opcion; 89. Console.SetCursorPosition(10,1); 90. Console.WriteLine("Menú:"); 91. Console.SetCursorPosition(0,3); 92. Console.WriteLine("Elija la operación que

quiere hacer:");



93. Console.WriteLine("1 - Suma de matrices"); 94. Console.WriteLine("2 - Resta de matrices"); 95. Console.WriteLine("3 - Producto por un

escalar"); 96. 97. opcion = byte.Parse (Console.ReadLine()); 98. 99. if (opcion >=1 && opcion <=3) { 100. Console.Clear(); 101. return opcion; 102. } 103. else { 104. Console.Clear(); 105. return 5; 106. } 107. } catch { //En caso de error 108. Console.Clear(); 109. return 5; 110. } 111. } 112. 113. // Función que lee los datos de las matrices 114. public static float [,] leer(int filas, int columnas) 115. { 116. float [,] ret = new float [filas, columnas]; 117. for (int fila = 0; fila < filas; fila++) 118. { 119. for (int columna = 0; columna <

columnas; columna++) 120. { 121. ret[fila,columna] =

float.Parse (Console.ReadLine()); 122. } 123. } 124. return ret; 125. } 126. 127. // La función suma 128. public static void suma (float [,] mat1, float [,] mat2) 129. { 130. Console.WriteLine ("La suma de sus dos

matrices es (enumeradas por filas)"); 131. for (int fila = 0; fila <=

mat2.GetUpperBound(0); fila++)


http://www.google.com/search?q=new+msdn.microsoft.com


132. { 133. for (int columna = 0; columna <=

mat2.GetUpperBound(1); columna++) 134. { 135. float suma; 136. suma = mat1[fila,columna]

+ mat2[fila,columna]; 137. Console.WriteLine

(suma.ToString()); 138. } 139. Console.WriteLine(""); 140. } 141. } 142. 143. // La función resta 144. public static void resta (float [,] mat1, float [,] mat2) 145. { 146. Console.WriteLine ("La resta de sus dos

matrices es (enumeradas por filas)"); 147. for (int fila = 0; fila <=

mat2.GetUpperBound(0); fila++) 148. { 149. for (int columna = 0; columna <=

mat2.GetUpperBound(1); columna++) 150. { 151. float resta; 152. resta = mat1[fila,columna] -

mat2[fila,columna]; 153. Console.WriteLine

(resta.ToString()); 154. } 155. Console.WriteLine(""); 156. } 157. } 158. 159. // Producto por un escalar 160. public static void prodEscalar (float [,] mat1, float

escalar) 161. { 162. Console.WriteLine ("La multiplicación del

escalar por su matriz es (enumerada por filas)"); 163. for (int fila = 0; fila <=

mat1.GetUpperBound(0); fila++) 164. {



165. for (int columna = 0; columna <= mat1.GetUpperBound(1); columna++)

166. { 167. float esc; 168. esc = mat1[fila,columna] *

escalar; 169. Console.WriteLine

(esc.ToString()); 170. } 171. Console.WriteLine(""); 172. } 173. } 174. } 175. }

Ejemplo 6:

Windows-pong, con dos botones y un radio buton simulo en clasico pong, muy cutre pero entretenido

1. using System; 2. using System.Collections.Generic; 3. using System.Drawing; 4. using System.Windows.Forms; 5. 6. namespace MiniJuegoPelota 7. { 8. /// <summary> 9. /// Description of MainForm. 10. /// </summary> 11. public partial class MainForm : Form 12. { 13. // 1 -> Derecha -1 -> Izquierda 14. // 1 -> Abajo -1 -> Arriba 15. private int dx = -1, dy = 1; 16. 17. // Variables q contiene la ultima tecla pulsada por cierta pala 18. // para q el rebote se efectue en una o otra direcion 19. // 'u' (up) -> arriba 'd' (down) -> abajo 20. private char d1, d2; 21. 22. 23. public MainForm() 24. { 25. InitializeComponent();



26. } 27. 28. void Timer1Tick(object sender, EventArgs e) 29. { 30. // Movemos la "pelota" 31. pelota.Left += dx; 32. pelota.Top += dy; 33. 34. // Para el movimiento de la pelota 35. 36. //dx = pelota.Location.X >= this.ClientSize.Width ? -1 :

dx; 37. //dx = pelota.Location.X == 0 ? 1 : dx; 38. 39. if (pelota.Location.X + 18 >= this.ClientSize.Width) 40. { 41. timer1.Enabled = false; 42. MessageBox.Show("Gana el jugador 1",

"Felicidades"); 43. } 44. if (pelota.Location.X == 0) 45. { 46. timer1.Enabled = false; 47. MessageBox.Show("Gana el jugador 2",

"Felicidades"); 48. } 49. 50. // Si choca contra la parte inferior o el menú 51. dy = pelota.Location.Y + 50 >= this.ClientSize.Width

? -1 : dy; 52. dy = pelota.Location.Y == 25 ? 1 : dy; 53. 54. // Si choca contra la pala1 55. if (pelota.Left == pala1.Left + pala1.Width) 56. { 57. if (pelota.Top > pala1.Top && pelota.Top <

pala1.Top + pala1.Height) 58. { 59. dx = 1; // Hacemos que valla hacia

la derecha 60. // y en funcion de la ultima tecla

pulsada hacia arriba o abajo 61. dy = d1 == 'u' ? -1 : 1; 62. }



63. } 64. 65. // Si choca contra la pala2 66. if (pelota.Left == pala2.Left - pala2.Width) 67. { 68. if (pelota.Top > pala2.Top && pelota.Top <

pala2.Top + pala2.Height) 69. { 70. dx = -1; // Hacemos que valla hacia

la izq 71. // y en funcion de la ultima tecla

pulsada hacia arriba o abajo 72. dy = d2 == 'u' ? -1 : 1; 73. } 74. } 75. 76. } 77. 78. 79. 80. //Para mover la pala 1 A = arriba, Z = abajo 81. //Para mover la pala 2 K = arriba, M = abajo 82. void MainFormKeyPress(object sender, KeyPressEventArgs

e) 83. { 84. switch (Char.ToUpper(e.KeyChar)) 85. { 86. case 'A': //La pala1 87. pala1.Top -= 10; 88. if (pala1.Top < 25) pala1.Top = 25; 89. d1 = 'u'; 90. break; 91. case 'Z': 92. pala1.Top += 10; 93. if (pala1.Top + pala1.Height >=

this.ClientSize.Height) pala1.Top = this.ClientSize.Height - pala1.Height; 94. d1 = 'd'; 95. break; 96. 97. case 'K': //La pala2 98. pala2.Top -= 10; 99. if (pala2.Top < 25) pala2.Top = 25; 100. d2 = 'u'; 101. break;



102. 103. case 'M': 104. pala2.Top += 10; 105. if (pala2.Top + pala2.Height >=

this.ClientSize.Height) pala2.Top = this.ClientSize.Height - pala2.Height; 106. d2 = 'd'; 107. break; 108. } 109. } 110. 111. 112. // Las opciones del menú 113. void NuevoToolStripMenuItemClick(object sender,

EventArgs e) 114. { 115. timer1.Enabled = true; 116. pelota.Left = 154; 117. pelota.Top = 134; 118. } 119. 120. void ContrrolesToolStripMenuItemClick(object

sender, EventArgs e) 121. { 122. MessageBox.Show ("Pulsar las teclas A y K

para subir y las teclas Z y M para bajar las respectivas paletas de los jugadores 1 y 2", "Controles");

123. } 124. 125. void SalirToolStripMenuItemClick(object sender,

EventArgs e) 126. { 127. Application.Exit(); 128. } 129. }


Identificar la importancia de un procedimiento.

La programación por procedimientos es un paradigma de la programación. Muchas veces es aplicable tanto en lenguajes de programación de bajo nivel como en lenguajes de alto nivel. En el caso de que esta técnica se aplique en lenguajes de alto nivel, recibirá el nombre de Programación funcional. Esta técnica consiste en basarse de un número muy bajo de expresiones repetidas,


http://es.wikipedia.org/wiki/Programaci%C3%B3n

http://es.wikipedia.org/wiki/Programaci%C3%B3n_funcional


englobarlas todas en un procedimiento o función y llamarlo cada vez que tenga que ejecutarse.

Esta técnica de programación ofrece muy buena respuesta con relación al tamaño de los programas, y en bruto casi no se nota en la velocidad de ejecución de los mismos (mientras que las variables, constantes o índices de vector estén en memoria, como suele ser normal, estos se relacionarán entre sí, sin una carga de memoria considerablemente alta para los procesadores modernos); aunque es muy complicado conseguir una programación por procedimientos pura.

• Programación funcional

En ciencias de la computación, la programación funcional es un paradigma de programación declarativa basado en la utilización de funciones aritméticas que no maneja datos mutables o de estado. Enfatiza la aplicación de funciones, en contraste con el estilo de programación imperativa, que enfatiza los cambios de estado. La programación funcional tiene sus raíces en el cálculo lambda, un sistema formal desarrollado en los 1930s para investigar la definición de función, la aplicación de las funciones y la recursión. Muchos lenguajes de programación funcionales pueden ser vistos como elaboraciones del cálculo lambda.

En la práctica, la diferencia entre una función matemática y la noción de una "función" utilizada en la programación imperativa es que las funciones imperativas pueden tener efectos secundarios, al cambiar el valor de cálculos realizados previamente. Por esta razón carecen de transparencia referencial, es decir, la misma expresión sintáctica puede resultar en valores diferentes en diferentes momentos dependiendo del estado del programa siendo ejecutado. Con código funcional, en contraste, el valor generado por una función depende exclusivamente de los argumentos alimentados a la función. Al eliminar los efectos secundarios se puede entender y predecir el comportamiento de un programa mucho más fácilmente, y esta es una de las principales motivaciones para utilizar la programación funcional.

Los lenguajes de programación funcional, especialmente los que son puramente funcionales, han sido enfatizados en el ambiente académico principalmente y no tanto en el desarrollo de software comercial. Sin embargo, lenguajes de programación importantes tales como Scheme, Erlang, Rust, Objective Caml y Haskell, han sido utilizados en aplicaciones comerciales e industriales por muchas organizaciones. La programación funcional también es utilizada en la industria a través de lenguajes de dominio específico como R (estadística), Mathematica (matemáticas simbólicas), J y K (análisis financiero), F# en Microsoft.NET y XSLT (XML). Lenguajes de uso específico usados


http://es.wikipedia.org/wiki/Variable_%28programaci%C3%B3n%29

http://es.wikipedia.org/wiki/Constante

http://es.wikipedia.org/wiki/Vector

http://es.wikipedia.org/wiki/Ciencias_de_la_computaci%C3%B3n

http://es.wikipedia.org/wiki/Paradigma_de_programaci%C3%B3n

http://es.wikipedia.org/wiki/Paradigma_de_programaci%C3%B3n

http://es.wikipedia.org/wiki/Programaci%C3%B3n_declarativa

http://es.wikipedia.org/wiki/Funci%C3%B3n_matem%C3%A1tica

http://es.wikipedia.org/wiki/Programaci%C3%B3n_imperativa

http://es.wikipedia.org/wiki/C%C3%A1lculo_lambda

http://es.wikipedia.org/wiki/Scheme

http://es.wikipedia.org/wiki/Erlang

http://es.wikipedia.org/wiki/Rust_%28lenguaje_de_programaci%C3%B3n%29

http://es.wikipedia.org/wiki/Objective_CAML

http://es.wikipedia.org/wiki/Haskell


comúnmente como SQL y Lex/Yacc, utilizan algunos elementos de programación funcional, especialmente al procesar valores mutables. Las hojas de cálculo también pueden ser consideradas lenguajes de programación funcional.

La programación funcional también puede ser desarrollada en lenguajes que no están diseñados específicamente para la programación funcional. En el caso de Perl, por ejemplo, que es un lenguaje de programación imperativo, existe un libro que describe como aplicar conceptos de programación funcional. JavaScript, uno de los lenguajes más ampliamente utilizados en la actualidad, también incorpora capacidades de programación funcional. Python también incorpora particularidades de los lenguajes funcionales como listas de comprensión y funciones de tratamiento de listas como matemática de conjuntos.

• Utilidad.

El objetivo es conseguir lenguajes expresivos y matemáticamente elegantes, en los que no sea necesario bajar al nivel de la máquina para describir el proceso llevado a cabo por el programa, y evitar el concepto de estado del cómputo. La secuencia de computaciones llevadas a cabo por el programa se rige única y exclusivamente por la reescritura de definiciones más amplias a otras cada vez más concretas y definidas, usando lo que se denominan "definiciones dirigidas".

• Características.

Los programas escritos en un lenguaje funcional están constituidos únicamentepor definiciones de funciones, entendiendo éstas no como subprogramas clásicos de un lenguaje imperativo, sino como funciones puramente matemáticas, en las que se verifican ciertas propiedades como la transparencia referencial (el significado de una expresión depende únicamente del significado de sus subexpresiones), y por tanto, la carencia total de efectos colaterales.

Otras características propias de estos lenguajes son la no existencia de asignaciones de variables y la falta de construcciones estructuradas como la secuencia o la iteración (lo que obliga en la práctica a que todas las repeticiones de instrucciones se lleven a cabo por medio de funciones recursivas).

Existen dos grandes categorías de lenguajes funcionales: los funcionales puros y los híbridos. La diferencia entre ambos estriba en que los lenguajes funcionales híbridos son menos dogmáticos que los puros, al admitir conceptos


http://es.wikipedia.org/wiki/Perl

http://es.wikipedia.org/wiki/JavaScript

http://es.wikipedia.org/wiki/Python

http://es.wikipedia.org/w/index.php?title=Definici%C3%B3n_dirigida&action=edit&redlink=1

http://es.wikipedia.org/wiki/Transparencia_referencial

http://es.wikipedia.org/wiki/Efecto_secundario_%28computaci%C3%B3n%29

http://es.wikipedia.org/wiki/Efecto_secundario_%28computaci%C3%B3n%29

http://es.wikipedia.org/wiki/Recursi%C3%B3n

http://es.wikipedia.org/wiki/Recursi%C3%B3n


tomados de los lenguajes imperativos, como las secuencias de instrucciones o la asignación de variables. En contraste, los lenguajes funcionales puros tienen una mayor potencia expresiva, conservando a la vez su transparencia referencial, algo que no se cumple siempre con un lenguaje funcional híbrido.

• Ventajas de usar un paradigma funcional.

Entre las ventajas que suelen citarse de usar un paradigma funcional en la programación de computadoras, están las siguientes:

- Ausencia de efectos colaterales. - Proceso de depuración menos problemático. - Pruebas de unidades más confiables. - Mayor facilidad para la ejecución concurrente.

PROGRAMAR PROCEDIMIENTOS PARA RESOLVER CASOS PRÁCTICOS.

Un programa o aplicación C# se compone de un conjunto de clases que contienen variables de diversos tipos utilizadas para almacenar datos, y métodos que implementan código capaz de manipular dichas variables y crear objetos o instancias de clase, que permitan la interacción con otros métodos y variables de esas clases.

El punto de inicio de todo programa C# es el código asociado al método Main (principal en inglés), es como la puerta de entrada del programa, lo primero que se ejecuta.

A la clase que contiene al método Main se la llama clase principal.

Las clases y métodos van entre llaves {} y al final de una instrucción o declaración de variable debe escribirse un punto y coma (;). Se utilizan tabuladores para sangrar las líneas de código con el fin de facilitar su legibilidad, aunque si se omiten no pasa nada.

El método Main ()

Cada aplicación de C# debe contener un método Main único, que especifique dónde debe comenzar la ejecución del programa. En C#, Main se pone en mayúsculas, mientras que Java utiliza main en minúscula.

Main puede devolver sólo int o void y tiene un argumento de matriz de cadena opcional para representar parámetros de línea de comandos:


http://es.wikipedia.org/wiki/Programaci%C3%B3n_imperativa

http://es.wikipedia.org/wiki/Depuraci%C3%B3n_de_programas


C#

static int Main(string[] args)

{

//...

return 0;

}

El parámetro de matriz de cadena, que contiene todos los argumentos de la línea de comandos pasados, funciona igual que en Java. Así, args[0] especifica el primer parámetro de línea de comandos, args[1] denota el segundo parámetro, etc. A diferencia de C++, la matriz args no contiene el nombre del archivo EXE.

Otros métodos.

Cuando se pasan parámetros a un método, se pueden pasar por valor o por referencia. Los parámetros de valor simplemente toman el valor de cualquier variable para utilizarlo en el método. Por lo tanto, el valor de variable en el código de llamada no se ve afectado por las acciones realizadas en los parámetros de un método.

Sin embargo, los parámetros de referencia apuntan a una variable declarada en el código de llamada; por lo tanto, los métodos modificarán el contenido de esa variable cuando se pase por referencia.

Envío de parámetros a los métodos.

Un método (procedimiento o función) puede recibir datos para realizar algunas acciones, los cuales se denominan parámetros o argumentos.

Existen dos formas de enviar datos a un método: por valor y por referencia.



Cuando se invoca un método al que se le envía un parámetro por valor, se le manda una copia del valor de una variable o expresión, el cual es recibido por un parámetro declarado del mismo tipo de dato que el valor enviado. En cambio, si se le envía un parámetro por referencia, se le manda la referencia (dirección de memoria) de una variable.

Se pueden enviar varios datos a un método, sin embargo es necesario precisar que las variables receptoras deben estar declaradas en el orden indicado por el envío, también considerando la correspondencia con el tipo de dato.

Cuando se invoca un método se colocan entre paréntesis los parámetros enviados.

Es importante mencionar que los parámetros que reciben los datos enviados al método se consideran variables locales (independientemente si se hace por valor o por referencia) e incluso pueden tener el mismo nombre que la variable origen, sin embargo se trata de copias de los valores originales, por lo tanto, son variables diferentes.

Envío de parámetros por valor

Cuando se envía un parámetro por valor, se hace una copia del valor de la variable enviada en el parámetro recibido, el cual actúa como una variable local, que lo recibe, lo manipula dentro del método y que desaparece y pierde su valor al terminar la ejecución de ese segmento de código.

Por ejemplo, al invocar (llamar) el método identificado con el nombre Procesar, se colocan entre paréntesis los parámetros Nombre, Edad y Sueldo separados por comas:

Procesar(Nombre, Edad, Sueldo);

La declaración del método se muestra enseguida:

void Procesar(string N, int E, double S)



{

………

}

En este caso, el parámetro N recibe una copia del valor de la variable Nombre, E recibe copia del valor de Edad y S recibe copia del valor de Sueldo Obsérvese que durante la llamada del método, se envían una cadena, un entero y un número real respectivamente, los cuales son recibidos en ese orden por los correspondientes parámetros; esto es, debe respetarse el orden de los tipos de datos enviados en la declaración de los parámetros.

Fig. .- Almacenamiento en memoria de los parámetros enviados por valor.

Ahora se considera el siguiente ejemplo: Declarar una variable global denominada “x“ y se inicializa con el valor 5 (x=5). Dentro del programa principal se declara y se inicializa una variable local llamada “y” con el valor 13 (y=13). Cuando se hace la llamada a un Metodo(y) y se envía la variable “y”, se hace por valor, es decir, se envía una copia del valor de la variable (13) que lo recibe otra variable local “a”. En ese momento, se transfiere el control de la ejecución del programa hacia el método, activando su variable local “a” y desactivando momentáneamente la variable local del programa principal “y” (la variable “x“ permanece activa ya que se trata de una variable global). Dentro del método, se modifica el valor de su variable local “a”, se imprime (16) y se duplica el valor de la variable global “x” y se imprime (10). Cuando el método termina, el sistema desactiva su variable local “a”, regresa el control de la ejecución del programa al lugar donde se hizo la llamada, activa y recupera el valor de su propia variable local (y=13) y continúa con su operación. Al imprimir



los valores, nos percatamos que la variable “x” modificó su valor por tratarse de una variable global que puede ser accedida en cualquier parte del programa, sin embargo, la variable “y” mantiene su valor original (no fué alterado), ya que por tratarse de una variable local, fue desactivada al llamar al Metodo() y reactivada con su valor original al retornar.

Enseguida se muestra el código en C# de este ejemplo

class Program { static int x = 5; // Variable global static void Main(string[] args)

{ int y = 13; // Variable local Console.WriteLine("\nx=" + x); // Llamada al método y envío por valor Metodo(y); Console.WriteLine("\nx=" + x); Console.WriteLine("\ny=" + y); Console.ReadKey(); }

// El parámetro "a" recibe el valor de "y" static void Metodo(int a)

{ a = a + 3; Console.WriteLine("\na=" + a); x = x * 2; }

} Salida del programa de envío de parámetros por valor: x=5 a=16 x=10 y=13

Pasar por referencia.

En Java y C#, los parámetros de método que hacen referencia a un objeto siempre se pasan por referencia, mientras que los parámetros de tipo de datos primitivo (tipos de valor en C#) se pasan por valor.

En C#, para pasar un tipo de valor por referencia, debe especificar una de las palabras clave ref o out. La diferencia entre estas dos palabras clave radica en la inicialización de los parámetros. Un parámetro ref se debe inicializar antes de su utilización, mientras que un parámetro out no debe inicializarse


http://msdn.microsoft.com/es-es/library/14akc2c7%28v=vs.90%29.aspx

http://msdn.microsoft.com/es-es/library/t3c3bfhx%28v=vs.90%29.aspx


explícitamente sin que antes se haya pasado por referencia y se haya omitido cualquier valor anterior.

Todas las variables se almacenan en celdas de la memoria RAM (Random Access Memory por sus siglas en inglés), las cuales están identificadas por una dirección expresada en números hexadecimales (p. ejem FA4D:32CE). Cuando se envía un parámetro por referencia, no se hace una copia de su valor y quien lo recibe, no contiene directamente el dato, sino una referencia (dirección de memoria) a él. El envío de parámetros por referencia permite a un método cambiar el valor del parámetro y mantener vigente dicho cambio. Cuando una variable es enviada por referencia, el método recibe la referencia de la variable original y esto implica que los cambios realizados a esa variable dentro del método, afectan la variable original. Para ilustrarlo mejor, consideremos el ejemplo de la sección anterior, pero ahora enviando la variable “y” por referencia: Se declara una variable global denominada “x” y se inicializa con el valor 5 (x=5). Dentro del programa principal se declara y se inicializa la variable “y” con el alor 13 (y=13), la cual se considera variable local al ser declarada dentro de un método. Cuando se hace la llamada del Método (ref y) y se envía la variable “y”, se hace por referencia, es decir, se envía la dirección de memoria (no el valor) de la variable “y”, que lo recibe 5 la variable local “a”. Dentro del método, se modifica el valor de la variable “a”, se imprime (16) y se duplica el valor de la variable global “x” (10) y se imprime. Cuando el método termina, el sistema desactiva su variable local “a”, regresa el control de la ejecución del programa al lugar donde se hizo la llamada, activa y recupera los valores de su propia variable local (y=13) y continúa con su operación. Al imprimir los valores, nos percatamos que la variable “x” modificó su valor por tratarse de una variable global que puede ser accedida en cualquier parte del programa y la variable “y”, aunque se trata de una variable local, también modificó su valor, ya que siendo la variable “a” una referencia de la variable “y”, entonces al modificar “a“ también se modifica “y”. Esto se debe a que la variable “a“ no recibe una copia del valor de la variable “y“ sino la dirección de memoria donde está almacenado dicho valor (FA31:C45C). A este concepto se le conocía con el nombre de apuntador en lenguajes como Pascal, C y C++, ya que la variable “a“ apunta al valor almacenado en la variable “y“.



El siguiente código en C# ilustra este ejemplo (Prog.2): class Program {

static int x = 5; // Variable global static void Main(string[] args) { int y = 13; // Variable local Console.WriteLine("\nx=" + x); // Llamada al método y envío por referencia Metodo(ref y); Console.WriteLine("\nx=" + x); Console.WriteLine("\ny=" + y); Console.ReadKey(); } // El parámetro "a" recibe la ref. de "y" static void Metodo(ref int a) { a = a + 3; Console.WriteLine("\na=" + a); x = x * 2; }

} Al ejecutar el programa anterior se produce la salida mostrada

x=5 a=16 x=10 y=16

Para monitorear los valores de las variables e identificar su ámbito, se recomienda ejecutar paso a paso por instrucciones este programa en Microsoft Visual C# 2010 ó 2012 oprimiendo repetidamente la tecla F11.



• Parámetros de salida out en C# .NET. Un parámetro de salida en C# (out) es muy similar a un parámetro por referencia (ref), excepto que los parámetros por referencia deben ser inicializados antes de enviarse; sin embargo, el método debe asignarle un valor antes de devolverlo. Para utilizar un parámetro de salida, basta con anteponer la palabra out tanto en el parámetro enviado como en su declaración en el método. Este tipo de parámetros son útiles cuando se requiere que una función devuelva más de un dato, ya que por definición, existe una restricción de que una función solamente devuelve un valor. Para ilustrar mejor el uso de un parámetro de salida, tomaremos como ejemplo el programa anterior (Prog. 2) al que se le agrega una variable booleana como parámetro de salida para determinar si el parámetro enviado por referencia es par ó impar. Este código en C# muestra este ejemplo (Prog. 3): class Program {

static int x = 5; // Variable global static void Main(string[] args) { int y = 13; // Variable local bool esImpar; Console.WriteLine("\nx=" + x); // Llamada al método y envío por referencia Metodo(ref y, out esImpar); Console.WriteLine("\nx=" + x); Console.WriteLine("\ny=" + y); if (esImpar)

Console.WriteLine("\ny es un número impar"); else

Console.WriteLine("\ny es un número par"); Console.ReadKey(); }

// El parámetro "a" recibe la referencia de "y" y el parámetro de salida sirve para determinar si el parámetro enviado es Impar static void Metodo (ref int a, out bool Impar)

{ a = a + 3; Console.WriteLine("\na=" + a); x = x * 2; if (a % 2 != 0)

Impar = true;



else Impar = false;

} } Prog.3.- Parámetro de salida en C#. Al ejecutar el programa anterior se produce la salida mostrada x=5 a=16 x=10 y=16 y es un número par

La palabra clave ref.

Especifique esta palabra clave en un parámetro de tipo de valor cuando desee que el método llamado cambie permanentemente el valor de las variables utilizadas como parámetros. De esta manera, en lugar de pasar el valor de una variable utilizada en la llamada, se pasa una referencia a la propia variable. Entonces el método funciona en la referencia, de modo que los cambios realizados al parámetro durante la ejecución del método se conservan en la variable original utilizada como parámetro para el método.

El código siguiente muestra un ejemplo de esto en el método Add, donde el segundo parámetro int se pasa por referencia con la palabra clave ref:

C#

class TestRef { private static void Add(int i, ref int result) { result += i; return; } static void Main() { int total = 20; System.Console.WriteLine("Original value of 'total': {0}", total); Add(10, ref total); System.Console.WriteLine("Value after calling Add(): {0}", total); } }


http://msdn.microsoft.com/es-es/library/5kzh1b5w%28v=vs.90%29.aspx


El resultado de este sencillo ejemplo demuestra que los cambios realizados al parámetro resultante se reflejan en la variable total, utilizada en la llamada al método Add :

Original value of 'total': 20

Value after calling Add(): 30

Esto se debe a que el parámetro resultante hace referencia a la ubicación de memoria real que ocupa la variable total en el código de llamada. Una propiedad de una clase no es una variable; por lo tanto, no se puede utilizar directamente como parámetro ref.

La palabra clave ref debe preceder al parámetro cuando se llama al método, al igual que en la declaración de método.

La palabra clave out.

La palabra clave out tiene un efecto muy similar a la palabra clave ref. Las modificaciones realizadas a un parámetro declarado que utiliza out serán visibles fuera del método. Las dos diferencias con respecto a ref son que todo valor inicial de un parámetro out se omite dentro del método y que un parámetro out se debe asignar durante la ejecución del método:

C#

class TestOut { private static void Add(int i, int j, out int result) { // The following line would cause a compile error: // System.Console.WriteLine("Initial value inside method: {0}", result); result = i + j; return; } static void Main() { int total = 20; System.Console.WriteLine("Original value of 'total': {0}", total); Add(33, 77, out total); System.Console.WriteLine("Value after calling Add(): {0}", total); }


http://msdn.microsoft.com/es-es/library/t3c3bfhx%28v=vs.90%29.aspx


}

En este caso, el tercer parámetro para el método Add se declara con la palabra clave out y las llamadas al método también necesitan la palabra clave out para ese parámetro. El resultado será:

Original value of 'total': 20

Value after calling Add(): 110

Por lo tanto, en resumen, utilice la palabra clave ref cuando desee que un método modifique una variable existente y utilice la palabra clave out, para devolver un valor generado dentro del método. Generalmente, esto se utiliza junto con el valor que el método devuelve cuando éste genera más de un valor resultante para el código de llamada.

Ejemplo:

Este programa consta de una clase de nombre PrimerSaludo, no declara ninguna variable y cuenta con dos métodos de nombres Main y MostrarMensaje. En programas más complejos, se tendrán varias clases, en cada clase habrá muchos métodos y declaraciones de variables, dentro de los métodos se declararán también variables, etc. Por el momento, con esta sencilla clase nos conformaremos. Se va a explicar ahora cada una de sus líneas.

La primera línea es la definición de una clase, la segunda es el método Main o punto de entrada del programa (además de esta forma, se puede definir de otras tres), la tercera es una instrucción o sentencia que muestra por la consola del DOS el mensaje entrecomillado, la cuarta sirve para crear un objeto de la clase llamado ps mediante el que se llama o invoca a otros métodos de la clase, la quinta es la llamada mediante el objeto ps al método



mostrarMensaje(), la sexta muestra por consola el mensaje entrecomillado. Luego aparece la definición del método MostrarMensaje() cuyo código hace que se muestre por consola el mensaje entrecomillado. Después de compilar y ejecutar este programa va a mostrarse por consola lo siguiente:

Por consola:

Hola Jesus Primera clase del curso de C# FIN DEL PROGRAMA

• Recibiendo un valor de una función.

Una vez que se invoca una función es necesario utilizar la variable capaz de recibir el valor devuelto por ésta, la cual debe ser del mismo tipo de la función. Por ejemplo, si se invoca el siguiente método x = Procesar(a, b); 7 la variable “x“ recibe el valor calculado por la función Procesar(), que acepta los parámetros “a“ y “b“ respectivamente.

Para ilustrarlo mejor, se considera el siguiente ejemplo: Se desea implementar una función que calcule el área de una circunferencia; para ello, la función recibe como parámetro el valor del radio,

aplica la fórmula correspondiente y devuelve el resultado calculado. El programa principal solicita al usuario capturar el valor del radio de una circunferencia y almacenarlo en la variable local llamada “Radio“, la cual es enviada como parámetro por valor a la función CalcularArea(), que recibe el parámetro en la variable local llamada “r“ aplica la fórmula ___ = _ y devuelve el resultado calculado al programa principal quien lo recibe en la variable “Area“. El siguiente código en C# ilustra este ejemplo (Prog. 4):

class Program { static void Main(string[] args) { double Radio, Area; Console.Write("Teclee el valor del radio:"); Radio = double.Parse(Console.ReadLine()); // La variable Area recibe el valor devuelto por la función Area = CalcularArea(Radio); Console.Write("Área = " + Area); Console.ReadKey(); }



static double CalcularArea(double r) { return (Math.PI * Math.Pow(r, 2)); }

} Prog. 4.- Función para calcular el área de una circunferencia Al ejecutar el programa anterior se produce la salida mostrada: Teclee el valor del radio: 2.3 Área = 16.61902513749

• Aplicaciones prácticas del uso de métodos. Existen numerosas aplicaciones prácticas del uso de métodos para el desarrollo de sistemas computacionales. La implementación de métodos ayuda a organizar mejor el diseño de programas y facilitan su mantenimiento. El Prog. 5 muestra una aplicación típica de un método al que se le envían parámetros: el ordenamiento de los datos de un arreglo. El programa principal solicita al usuario que capture la cantidad de celdas de un arreglo unidimensional y lo almacena en la variable local llamada “Tamaño”, crea el arreglo local y lo llena con números enteros generados de manera aleatoria. Después invoca al procedimiento llamado Ordenar() y le envía como parámetros el “Arreglo” completo y su “Tamaño” (los cuales son recibidos por el arreglo “A” y la variable “T” respectivamente) para implementar un algoritmo que ordena de manera ascendente (de menor a mayor) los datos almacenados en el arreglo (en este momento no es importante explicar el método de ordenamiento). Obsérvese que se trata de un procedimiento, puesto que no devuelve valor; sin embargo, no es necesario devolver valor alguno, ya que cuando se envía un arreglo como parámetro a un método, automáticamente se hace por referencia; es decir, no se requiere implementar una función que devuelva el arreglo con los datos ordenados; sino que al hacer los cambios en el arreglo recibido dentro del método (arreglo “A”), éstos se reflejan de manera inmediata en el arreglo original (Arreglo) que fue generado en el programa principal. El siguiente código en C# muestra este ejemplo: class Program {

static void Main(string[] args) { // Declaración del tamaño del arreglo int Tamaño; // Declaración del arreglo



int [] Arreglo; // Generar un número aleatorio Random NumeroAleatorio = new Random(int.MaxValue); Console.Write("Teclee el tamaño del arreglo:"); Tamaño = int.Parse(Console.ReadLine()); // Creación del arreglo Arreglo = new int[Tamaño]; // Llena el Arreglo con números generadosaleatoriamente Console.WriteLine("\nARREGLO DESORDENADO\n"); for (int i = 0; i < Tamaño; i++) {

// Genera núm. aleatorio y lo almacena en la celda "i" del Arreglo Arreglo[i] = NumeroAleatorio.Next(); // Imprime el núm. generado Console.WriteLine("{0:N0} ",Arreglo[i]);

} Console.Write("\nOprima cualquier tecla para ordenar el arreglo ..."); Console.ReadKey(); // Invoca el procedimiento "Ordenar" y le envía el "Arreglo" y su "Tamaño" Ordenar(Arreglo, Tamaño); // Limpia la pantalla Console.Clear(); // Imprime el arreglo Console.WriteLine("ARREGLO ORDENADO\n"); for(int i=0; i<Tamaño; i++)

Console.WriteLine("{0:N0} ", Arreglo[i]); Console.Write("\nOprima cualquier tecla para salir ...");

Console.ReadKey(); } // Procedimiento para ordenar un arreglo recibido como parámetro static void Ordenar(int[] A, int T) {

for(int p=0; p<T-1; p++) for(int e=p+1; e<T; e++) if (A[e] < A[p]) {

int temp=A[p]; A[p] = A[e]; A[e] = temp;

} }

}



Al ejecutar el programa anterior se produce la salida mostrada: Teclee el tamaño del arreglo: 6 ARREGLO DESORDENADO 1,559,595,546 1,755,192,844 1,649,316,172 1,198,642,031 442,452,829 1,200,195,955

Oprima cualquier tecla para ordenar el arreglo ARREGLO ORDENADO 442,452,829 1,198,642,031 1,200,195,955 1,559,595,546 1,649,316,172 1,755,192,844

Oprima cualquier tecla para salir



1. Crear una función que tenga como entrada dos valores enteros, m y n, y determine si m es múltiplo de n. La función devolverá un valor lógico. En el programa principal reportar el resultado de dicha función.

2. Crear una función que tenga como entradas 3 números y devuelva el mayor de ellos. En el programa principal reportar el resultado.

3. Crear un subprograma que reciba como entrada un valor entero e indique si se trata de un número par o impar. ¿Qué tipo de subprograma cree que es el más apropiado, procedimiento o función? En el programa principal reportar el resultado.

4. Crear un procedimiento que reciba tres valores reales como entrada y los ordene de mayor a menor. En el programa principal reportar el resultado.

5. Crear un subprograma apropiado que lea por teclado una secuencia de números enteros positivos entre 0 y 100, ambos inclusive. La secuencia de números introducidos terminará cuando se introduzca un número que no cumpla la condición (que no esté entre 0 y 100). En el programa principal reportar los valores leídos y el número de valores que hay dentro del arreglo.



Documents

MANUAL DE APRENDIZAJE - virtual.senati.edu.pevirtual.senati.edu.pe/curri/file_curri.php/curri/PDSD/89001562... · elaborar casos prÁcticos utilizando estructuras repetitivas.....169